1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package cloudwatchlogs
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/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_serializeOpAssociateKmsKey struct {
18}
19
20func (*awsAwsjson11_serializeOpAssociateKmsKey) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsAwsjson11_serializeOpAssociateKmsKey) 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.(*AssociateKmsKeyInput)
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("Logs_20140328.AssociateKmsKey")
46
47	jsonEncoder := smithyjson.NewEncoder()
48	if err := awsAwsjson11_serializeOpDocumentAssociateKmsKeyInput(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_serializeOpCancelExportTask struct {
65}
66
67func (*awsAwsjson11_serializeOpCancelExportTask) ID() string {
68	return "OperationSerializer"
69}
70
71func (m *awsAwsjson11_serializeOpCancelExportTask) 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.(*CancelExportTaskInput)
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("Logs_20140328.CancelExportTask")
93
94	jsonEncoder := smithyjson.NewEncoder()
95	if err := awsAwsjson11_serializeOpDocumentCancelExportTaskInput(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_serializeOpCreateExportTask struct {
112}
113
114func (*awsAwsjson11_serializeOpCreateExportTask) ID() string {
115	return "OperationSerializer"
116}
117
118func (m *awsAwsjson11_serializeOpCreateExportTask) 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.(*CreateExportTaskInput)
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("Logs_20140328.CreateExportTask")
140
141	jsonEncoder := smithyjson.NewEncoder()
142	if err := awsAwsjson11_serializeOpDocumentCreateExportTaskInput(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_serializeOpCreateLogGroup struct {
159}
160
161func (*awsAwsjson11_serializeOpCreateLogGroup) ID() string {
162	return "OperationSerializer"
163}
164
165func (m *awsAwsjson11_serializeOpCreateLogGroup) 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.(*CreateLogGroupInput)
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("Logs_20140328.CreateLogGroup")
187
188	jsonEncoder := smithyjson.NewEncoder()
189	if err := awsAwsjson11_serializeOpDocumentCreateLogGroupInput(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_serializeOpCreateLogStream struct {
206}
207
208func (*awsAwsjson11_serializeOpCreateLogStream) ID() string {
209	return "OperationSerializer"
210}
211
212func (m *awsAwsjson11_serializeOpCreateLogStream) 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.(*CreateLogStreamInput)
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("Logs_20140328.CreateLogStream")
234
235	jsonEncoder := smithyjson.NewEncoder()
236	if err := awsAwsjson11_serializeOpDocumentCreateLogStreamInput(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_serializeOpDeleteDestination struct {
253}
254
255func (*awsAwsjson11_serializeOpDeleteDestination) ID() string {
256	return "OperationSerializer"
257}
258
259func (m *awsAwsjson11_serializeOpDeleteDestination) 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.(*DeleteDestinationInput)
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("Logs_20140328.DeleteDestination")
281
282	jsonEncoder := smithyjson.NewEncoder()
283	if err := awsAwsjson11_serializeOpDocumentDeleteDestinationInput(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_serializeOpDeleteLogGroup struct {
300}
301
302func (*awsAwsjson11_serializeOpDeleteLogGroup) ID() string {
303	return "OperationSerializer"
304}
305
306func (m *awsAwsjson11_serializeOpDeleteLogGroup) 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.(*DeleteLogGroupInput)
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("Logs_20140328.DeleteLogGroup")
328
329	jsonEncoder := smithyjson.NewEncoder()
330	if err := awsAwsjson11_serializeOpDocumentDeleteLogGroupInput(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_serializeOpDeleteLogStream struct {
347}
348
349func (*awsAwsjson11_serializeOpDeleteLogStream) ID() string {
350	return "OperationSerializer"
351}
352
353func (m *awsAwsjson11_serializeOpDeleteLogStream) 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.(*DeleteLogStreamInput)
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("Logs_20140328.DeleteLogStream")
375
376	jsonEncoder := smithyjson.NewEncoder()
377	if err := awsAwsjson11_serializeOpDocumentDeleteLogStreamInput(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_serializeOpDeleteMetricFilter struct {
394}
395
396func (*awsAwsjson11_serializeOpDeleteMetricFilter) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsAwsjson11_serializeOpDeleteMetricFilter) 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.(*DeleteMetricFilterInput)
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("Logs_20140328.DeleteMetricFilter")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsAwsjson11_serializeOpDocumentDeleteMetricFilterInput(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_serializeOpDeleteQueryDefinition struct {
441}
442
443func (*awsAwsjson11_serializeOpDeleteQueryDefinition) ID() string {
444	return "OperationSerializer"
445}
446
447func (m *awsAwsjson11_serializeOpDeleteQueryDefinition) 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.(*DeleteQueryDefinitionInput)
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("Logs_20140328.DeleteQueryDefinition")
469
470	jsonEncoder := smithyjson.NewEncoder()
471	if err := awsAwsjson11_serializeOpDocumentDeleteQueryDefinitionInput(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_serializeOpDeleteResourcePolicy struct {
488}
489
490func (*awsAwsjson11_serializeOpDeleteResourcePolicy) ID() string {
491	return "OperationSerializer"
492}
493
494func (m *awsAwsjson11_serializeOpDeleteResourcePolicy) 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.(*DeleteResourcePolicyInput)
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("Logs_20140328.DeleteResourcePolicy")
516
517	jsonEncoder := smithyjson.NewEncoder()
518	if err := awsAwsjson11_serializeOpDocumentDeleteResourcePolicyInput(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_serializeOpDeleteRetentionPolicy struct {
535}
536
537func (*awsAwsjson11_serializeOpDeleteRetentionPolicy) ID() string {
538	return "OperationSerializer"
539}
540
541func (m *awsAwsjson11_serializeOpDeleteRetentionPolicy) 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.(*DeleteRetentionPolicyInput)
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("Logs_20140328.DeleteRetentionPolicy")
563
564	jsonEncoder := smithyjson.NewEncoder()
565	if err := awsAwsjson11_serializeOpDocumentDeleteRetentionPolicyInput(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_serializeOpDeleteSubscriptionFilter struct {
582}
583
584func (*awsAwsjson11_serializeOpDeleteSubscriptionFilter) ID() string {
585	return "OperationSerializer"
586}
587
588func (m *awsAwsjson11_serializeOpDeleteSubscriptionFilter) 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.(*DeleteSubscriptionFilterInput)
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("Logs_20140328.DeleteSubscriptionFilter")
610
611	jsonEncoder := smithyjson.NewEncoder()
612	if err := awsAwsjson11_serializeOpDocumentDeleteSubscriptionFilterInput(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_serializeOpDescribeDestinations struct {
629}
630
631func (*awsAwsjson11_serializeOpDescribeDestinations) ID() string {
632	return "OperationSerializer"
633}
634
635func (m *awsAwsjson11_serializeOpDescribeDestinations) 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.(*DescribeDestinationsInput)
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("Logs_20140328.DescribeDestinations")
657
658	jsonEncoder := smithyjson.NewEncoder()
659	if err := awsAwsjson11_serializeOpDocumentDescribeDestinationsInput(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_serializeOpDescribeExportTasks struct {
676}
677
678func (*awsAwsjson11_serializeOpDescribeExportTasks) ID() string {
679	return "OperationSerializer"
680}
681
682func (m *awsAwsjson11_serializeOpDescribeExportTasks) 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.(*DescribeExportTasksInput)
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("Logs_20140328.DescribeExportTasks")
704
705	jsonEncoder := smithyjson.NewEncoder()
706	if err := awsAwsjson11_serializeOpDocumentDescribeExportTasksInput(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_serializeOpDescribeLogGroups struct {
723}
724
725func (*awsAwsjson11_serializeOpDescribeLogGroups) ID() string {
726	return "OperationSerializer"
727}
728
729func (m *awsAwsjson11_serializeOpDescribeLogGroups) 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.(*DescribeLogGroupsInput)
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("Logs_20140328.DescribeLogGroups")
751
752	jsonEncoder := smithyjson.NewEncoder()
753	if err := awsAwsjson11_serializeOpDocumentDescribeLogGroupsInput(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_serializeOpDescribeLogStreams struct {
770}
771
772func (*awsAwsjson11_serializeOpDescribeLogStreams) ID() string {
773	return "OperationSerializer"
774}
775
776func (m *awsAwsjson11_serializeOpDescribeLogStreams) 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.(*DescribeLogStreamsInput)
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("Logs_20140328.DescribeLogStreams")
798
799	jsonEncoder := smithyjson.NewEncoder()
800	if err := awsAwsjson11_serializeOpDocumentDescribeLogStreamsInput(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_serializeOpDescribeMetricFilters struct {
817}
818
819func (*awsAwsjson11_serializeOpDescribeMetricFilters) ID() string {
820	return "OperationSerializer"
821}
822
823func (m *awsAwsjson11_serializeOpDescribeMetricFilters) 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.(*DescribeMetricFiltersInput)
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("Logs_20140328.DescribeMetricFilters")
845
846	jsonEncoder := smithyjson.NewEncoder()
847	if err := awsAwsjson11_serializeOpDocumentDescribeMetricFiltersInput(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_serializeOpDescribeQueries struct {
864}
865
866func (*awsAwsjson11_serializeOpDescribeQueries) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsAwsjson11_serializeOpDescribeQueries) 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.(*DescribeQueriesInput)
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("Logs_20140328.DescribeQueries")
892
893	jsonEncoder := smithyjson.NewEncoder()
894	if err := awsAwsjson11_serializeOpDocumentDescribeQueriesInput(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_serializeOpDescribeQueryDefinitions struct {
911}
912
913func (*awsAwsjson11_serializeOpDescribeQueryDefinitions) ID() string {
914	return "OperationSerializer"
915}
916
917func (m *awsAwsjson11_serializeOpDescribeQueryDefinitions) 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.(*DescribeQueryDefinitionsInput)
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("Logs_20140328.DescribeQueryDefinitions")
939
940	jsonEncoder := smithyjson.NewEncoder()
941	if err := awsAwsjson11_serializeOpDocumentDescribeQueryDefinitionsInput(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_serializeOpDescribeResourcePolicies struct {
958}
959
960func (*awsAwsjson11_serializeOpDescribeResourcePolicies) ID() string {
961	return "OperationSerializer"
962}
963
964func (m *awsAwsjson11_serializeOpDescribeResourcePolicies) 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.(*DescribeResourcePoliciesInput)
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("Logs_20140328.DescribeResourcePolicies")
986
987	jsonEncoder := smithyjson.NewEncoder()
988	if err := awsAwsjson11_serializeOpDocumentDescribeResourcePoliciesInput(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_serializeOpDescribeSubscriptionFilters struct {
1005}
1006
1007func (*awsAwsjson11_serializeOpDescribeSubscriptionFilters) ID() string {
1008	return "OperationSerializer"
1009}
1010
1011func (m *awsAwsjson11_serializeOpDescribeSubscriptionFilters) 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.(*DescribeSubscriptionFiltersInput)
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("Logs_20140328.DescribeSubscriptionFilters")
1033
1034	jsonEncoder := smithyjson.NewEncoder()
1035	if err := awsAwsjson11_serializeOpDocumentDescribeSubscriptionFiltersInput(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_serializeOpDisassociateKmsKey struct {
1052}
1053
1054func (*awsAwsjson11_serializeOpDisassociateKmsKey) ID() string {
1055	return "OperationSerializer"
1056}
1057
1058func (m *awsAwsjson11_serializeOpDisassociateKmsKey) 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.(*DisassociateKmsKeyInput)
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("Logs_20140328.DisassociateKmsKey")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsAwsjson11_serializeOpDocumentDisassociateKmsKeyInput(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_serializeOpFilterLogEvents struct {
1099}
1100
1101func (*awsAwsjson11_serializeOpFilterLogEvents) ID() string {
1102	return "OperationSerializer"
1103}
1104
1105func (m *awsAwsjson11_serializeOpFilterLogEvents) 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.(*FilterLogEventsInput)
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("Logs_20140328.FilterLogEvents")
1127
1128	jsonEncoder := smithyjson.NewEncoder()
1129	if err := awsAwsjson11_serializeOpDocumentFilterLogEventsInput(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_serializeOpGetLogEvents struct {
1146}
1147
1148func (*awsAwsjson11_serializeOpGetLogEvents) ID() string {
1149	return "OperationSerializer"
1150}
1151
1152func (m *awsAwsjson11_serializeOpGetLogEvents) 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.(*GetLogEventsInput)
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("Logs_20140328.GetLogEvents")
1174
1175	jsonEncoder := smithyjson.NewEncoder()
1176	if err := awsAwsjson11_serializeOpDocumentGetLogEventsInput(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_serializeOpGetLogGroupFields struct {
1193}
1194
1195func (*awsAwsjson11_serializeOpGetLogGroupFields) ID() string {
1196	return "OperationSerializer"
1197}
1198
1199func (m *awsAwsjson11_serializeOpGetLogGroupFields) 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.(*GetLogGroupFieldsInput)
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("Logs_20140328.GetLogGroupFields")
1221
1222	jsonEncoder := smithyjson.NewEncoder()
1223	if err := awsAwsjson11_serializeOpDocumentGetLogGroupFieldsInput(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_serializeOpGetLogRecord struct {
1240}
1241
1242func (*awsAwsjson11_serializeOpGetLogRecord) ID() string {
1243	return "OperationSerializer"
1244}
1245
1246func (m *awsAwsjson11_serializeOpGetLogRecord) 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.(*GetLogRecordInput)
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("Logs_20140328.GetLogRecord")
1268
1269	jsonEncoder := smithyjson.NewEncoder()
1270	if err := awsAwsjson11_serializeOpDocumentGetLogRecordInput(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_serializeOpGetQueryResults struct {
1287}
1288
1289func (*awsAwsjson11_serializeOpGetQueryResults) ID() string {
1290	return "OperationSerializer"
1291}
1292
1293func (m *awsAwsjson11_serializeOpGetQueryResults) 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.(*GetQueryResultsInput)
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("Logs_20140328.GetQueryResults")
1315
1316	jsonEncoder := smithyjson.NewEncoder()
1317	if err := awsAwsjson11_serializeOpDocumentGetQueryResultsInput(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_serializeOpListTagsLogGroup struct {
1334}
1335
1336func (*awsAwsjson11_serializeOpListTagsLogGroup) ID() string {
1337	return "OperationSerializer"
1338}
1339
1340func (m *awsAwsjson11_serializeOpListTagsLogGroup) 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.(*ListTagsLogGroupInput)
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("Logs_20140328.ListTagsLogGroup")
1362
1363	jsonEncoder := smithyjson.NewEncoder()
1364	if err := awsAwsjson11_serializeOpDocumentListTagsLogGroupInput(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_serializeOpPutDestination struct {
1381}
1382
1383func (*awsAwsjson11_serializeOpPutDestination) ID() string {
1384	return "OperationSerializer"
1385}
1386
1387func (m *awsAwsjson11_serializeOpPutDestination) 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.(*PutDestinationInput)
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("Logs_20140328.PutDestination")
1409
1410	jsonEncoder := smithyjson.NewEncoder()
1411	if err := awsAwsjson11_serializeOpDocumentPutDestinationInput(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_serializeOpPutDestinationPolicy struct {
1428}
1429
1430func (*awsAwsjson11_serializeOpPutDestinationPolicy) ID() string {
1431	return "OperationSerializer"
1432}
1433
1434func (m *awsAwsjson11_serializeOpPutDestinationPolicy) 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.(*PutDestinationPolicyInput)
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("Logs_20140328.PutDestinationPolicy")
1456
1457	jsonEncoder := smithyjson.NewEncoder()
1458	if err := awsAwsjson11_serializeOpDocumentPutDestinationPolicyInput(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_serializeOpPutLogEvents struct {
1475}
1476
1477func (*awsAwsjson11_serializeOpPutLogEvents) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsjson11_serializeOpPutLogEvents) 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.(*PutLogEventsInput)
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("Logs_20140328.PutLogEvents")
1503
1504	jsonEncoder := smithyjson.NewEncoder()
1505	if err := awsAwsjson11_serializeOpDocumentPutLogEventsInput(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_serializeOpPutMetricFilter struct {
1522}
1523
1524func (*awsAwsjson11_serializeOpPutMetricFilter) ID() string {
1525	return "OperationSerializer"
1526}
1527
1528func (m *awsAwsjson11_serializeOpPutMetricFilter) 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.(*PutMetricFilterInput)
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("Logs_20140328.PutMetricFilter")
1550
1551	jsonEncoder := smithyjson.NewEncoder()
1552	if err := awsAwsjson11_serializeOpDocumentPutMetricFilterInput(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_serializeOpPutQueryDefinition struct {
1569}
1570
1571func (*awsAwsjson11_serializeOpPutQueryDefinition) ID() string {
1572	return "OperationSerializer"
1573}
1574
1575func (m *awsAwsjson11_serializeOpPutQueryDefinition) 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.(*PutQueryDefinitionInput)
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("Logs_20140328.PutQueryDefinition")
1597
1598	jsonEncoder := smithyjson.NewEncoder()
1599	if err := awsAwsjson11_serializeOpDocumentPutQueryDefinitionInput(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("Logs_20140328.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_serializeOpPutRetentionPolicy struct {
1663}
1664
1665func (*awsAwsjson11_serializeOpPutRetentionPolicy) ID() string {
1666	return "OperationSerializer"
1667}
1668
1669func (m *awsAwsjson11_serializeOpPutRetentionPolicy) 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.(*PutRetentionPolicyInput)
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("Logs_20140328.PutRetentionPolicy")
1691
1692	jsonEncoder := smithyjson.NewEncoder()
1693	if err := awsAwsjson11_serializeOpDocumentPutRetentionPolicyInput(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_serializeOpPutSubscriptionFilter struct {
1710}
1711
1712func (*awsAwsjson11_serializeOpPutSubscriptionFilter) ID() string {
1713	return "OperationSerializer"
1714}
1715
1716func (m *awsAwsjson11_serializeOpPutSubscriptionFilter) 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.(*PutSubscriptionFilterInput)
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("Logs_20140328.PutSubscriptionFilter")
1738
1739	jsonEncoder := smithyjson.NewEncoder()
1740	if err := awsAwsjson11_serializeOpDocumentPutSubscriptionFilterInput(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_serializeOpStartQuery struct {
1757}
1758
1759func (*awsAwsjson11_serializeOpStartQuery) ID() string {
1760	return "OperationSerializer"
1761}
1762
1763func (m *awsAwsjson11_serializeOpStartQuery) 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.(*StartQueryInput)
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("Logs_20140328.StartQuery")
1785
1786	jsonEncoder := smithyjson.NewEncoder()
1787	if err := awsAwsjson11_serializeOpDocumentStartQueryInput(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_serializeOpStopQuery struct {
1804}
1805
1806func (*awsAwsjson11_serializeOpStopQuery) ID() string {
1807	return "OperationSerializer"
1808}
1809
1810func (m *awsAwsjson11_serializeOpStopQuery) 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.(*StopQueryInput)
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("Logs_20140328.StopQuery")
1832
1833	jsonEncoder := smithyjson.NewEncoder()
1834	if err := awsAwsjson11_serializeOpDocumentStopQueryInput(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_serializeOpTagLogGroup struct {
1851}
1852
1853func (*awsAwsjson11_serializeOpTagLogGroup) ID() string {
1854	return "OperationSerializer"
1855}
1856
1857func (m *awsAwsjson11_serializeOpTagLogGroup) 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.(*TagLogGroupInput)
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("Logs_20140328.TagLogGroup")
1879
1880	jsonEncoder := smithyjson.NewEncoder()
1881	if err := awsAwsjson11_serializeOpDocumentTagLogGroupInput(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_serializeOpTestMetricFilter struct {
1898}
1899
1900func (*awsAwsjson11_serializeOpTestMetricFilter) ID() string {
1901	return "OperationSerializer"
1902}
1903
1904func (m *awsAwsjson11_serializeOpTestMetricFilter) 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.(*TestMetricFilterInput)
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("Logs_20140328.TestMetricFilter")
1926
1927	jsonEncoder := smithyjson.NewEncoder()
1928	if err := awsAwsjson11_serializeOpDocumentTestMetricFilterInput(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_serializeOpUntagLogGroup struct {
1945}
1946
1947func (*awsAwsjson11_serializeOpUntagLogGroup) ID() string {
1948	return "OperationSerializer"
1949}
1950
1951func (m *awsAwsjson11_serializeOpUntagLogGroup) 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.(*UntagLogGroupInput)
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("Logs_20140328.UntagLogGroup")
1973
1974	jsonEncoder := smithyjson.NewEncoder()
1975	if err := awsAwsjson11_serializeOpDocumentUntagLogGroupInput(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}
1990func awsAwsjson11_serializeDocumentInputLogEvent(v *types.InputLogEvent, value smithyjson.Value) error {
1991	object := value.Object()
1992	defer object.Close()
1993
1994	if v.Message != nil {
1995		ok := object.Key("message")
1996		ok.String(*v.Message)
1997	}
1998
1999	if v.Timestamp != nil {
2000		ok := object.Key("timestamp")
2001		ok.Long(*v.Timestamp)
2002	}
2003
2004	return nil
2005}
2006
2007func awsAwsjson11_serializeDocumentInputLogEvents(v []types.InputLogEvent, value smithyjson.Value) error {
2008	array := value.Array()
2009	defer array.Close()
2010
2011	for i := range v {
2012		av := array.Value()
2013		if err := awsAwsjson11_serializeDocumentInputLogEvent(&v[i], av); err != nil {
2014			return err
2015		}
2016	}
2017	return nil
2018}
2019
2020func awsAwsjson11_serializeDocumentInputLogStreamNames(v []string, value smithyjson.Value) error {
2021	array := value.Array()
2022	defer array.Close()
2023
2024	for i := range v {
2025		av := array.Value()
2026		av.String(v[i])
2027	}
2028	return nil
2029}
2030
2031func awsAwsjson11_serializeDocumentLogGroupNames(v []string, value smithyjson.Value) error {
2032	array := value.Array()
2033	defer array.Close()
2034
2035	for i := range v {
2036		av := array.Value()
2037		av.String(v[i])
2038	}
2039	return nil
2040}
2041
2042func awsAwsjson11_serializeDocumentMetricTransformation(v *types.MetricTransformation, value smithyjson.Value) error {
2043	object := value.Object()
2044	defer object.Close()
2045
2046	if v.DefaultValue != nil {
2047		ok := object.Key("defaultValue")
2048		ok.Double(*v.DefaultValue)
2049	}
2050
2051	if v.MetricName != nil {
2052		ok := object.Key("metricName")
2053		ok.String(*v.MetricName)
2054	}
2055
2056	if v.MetricNamespace != nil {
2057		ok := object.Key("metricNamespace")
2058		ok.String(*v.MetricNamespace)
2059	}
2060
2061	if v.MetricValue != nil {
2062		ok := object.Key("metricValue")
2063		ok.String(*v.MetricValue)
2064	}
2065
2066	return nil
2067}
2068
2069func awsAwsjson11_serializeDocumentMetricTransformations(v []types.MetricTransformation, value smithyjson.Value) error {
2070	array := value.Array()
2071	defer array.Close()
2072
2073	for i := range v {
2074		av := array.Value()
2075		if err := awsAwsjson11_serializeDocumentMetricTransformation(&v[i], av); err != nil {
2076			return err
2077		}
2078	}
2079	return nil
2080}
2081
2082func awsAwsjson11_serializeDocumentTagList(v []string, value smithyjson.Value) error {
2083	array := value.Array()
2084	defer array.Close()
2085
2086	for i := range v {
2087		av := array.Value()
2088		av.String(v[i])
2089	}
2090	return nil
2091}
2092
2093func awsAwsjson11_serializeDocumentTags(v map[string]string, value smithyjson.Value) error {
2094	object := value.Object()
2095	defer object.Close()
2096
2097	for key := range v {
2098		om := object.Key(key)
2099		om.String(v[key])
2100	}
2101	return nil
2102}
2103
2104func awsAwsjson11_serializeDocumentTestEventMessages(v []string, value smithyjson.Value) error {
2105	array := value.Array()
2106	defer array.Close()
2107
2108	for i := range v {
2109		av := array.Value()
2110		av.String(v[i])
2111	}
2112	return nil
2113}
2114
2115func awsAwsjson11_serializeOpDocumentAssociateKmsKeyInput(v *AssociateKmsKeyInput, value smithyjson.Value) error {
2116	object := value.Object()
2117	defer object.Close()
2118
2119	if v.KmsKeyId != nil {
2120		ok := object.Key("kmsKeyId")
2121		ok.String(*v.KmsKeyId)
2122	}
2123
2124	if v.LogGroupName != nil {
2125		ok := object.Key("logGroupName")
2126		ok.String(*v.LogGroupName)
2127	}
2128
2129	return nil
2130}
2131
2132func awsAwsjson11_serializeOpDocumentCancelExportTaskInput(v *CancelExportTaskInput, value smithyjson.Value) error {
2133	object := value.Object()
2134	defer object.Close()
2135
2136	if v.TaskId != nil {
2137		ok := object.Key("taskId")
2138		ok.String(*v.TaskId)
2139	}
2140
2141	return nil
2142}
2143
2144func awsAwsjson11_serializeOpDocumentCreateExportTaskInput(v *CreateExportTaskInput, value smithyjson.Value) error {
2145	object := value.Object()
2146	defer object.Close()
2147
2148	if v.Destination != nil {
2149		ok := object.Key("destination")
2150		ok.String(*v.Destination)
2151	}
2152
2153	if v.DestinationPrefix != nil {
2154		ok := object.Key("destinationPrefix")
2155		ok.String(*v.DestinationPrefix)
2156	}
2157
2158	if v.From != nil {
2159		ok := object.Key("from")
2160		ok.Long(*v.From)
2161	}
2162
2163	if v.LogGroupName != nil {
2164		ok := object.Key("logGroupName")
2165		ok.String(*v.LogGroupName)
2166	}
2167
2168	if v.LogStreamNamePrefix != nil {
2169		ok := object.Key("logStreamNamePrefix")
2170		ok.String(*v.LogStreamNamePrefix)
2171	}
2172
2173	if v.TaskName != nil {
2174		ok := object.Key("taskName")
2175		ok.String(*v.TaskName)
2176	}
2177
2178	if v.To != nil {
2179		ok := object.Key("to")
2180		ok.Long(*v.To)
2181	}
2182
2183	return nil
2184}
2185
2186func awsAwsjson11_serializeOpDocumentCreateLogGroupInput(v *CreateLogGroupInput, value smithyjson.Value) error {
2187	object := value.Object()
2188	defer object.Close()
2189
2190	if v.KmsKeyId != nil {
2191		ok := object.Key("kmsKeyId")
2192		ok.String(*v.KmsKeyId)
2193	}
2194
2195	if v.LogGroupName != nil {
2196		ok := object.Key("logGroupName")
2197		ok.String(*v.LogGroupName)
2198	}
2199
2200	if v.Tags != nil {
2201		ok := object.Key("tags")
2202		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2203			return err
2204		}
2205	}
2206
2207	return nil
2208}
2209
2210func awsAwsjson11_serializeOpDocumentCreateLogStreamInput(v *CreateLogStreamInput, value smithyjson.Value) error {
2211	object := value.Object()
2212	defer object.Close()
2213
2214	if v.LogGroupName != nil {
2215		ok := object.Key("logGroupName")
2216		ok.String(*v.LogGroupName)
2217	}
2218
2219	if v.LogStreamName != nil {
2220		ok := object.Key("logStreamName")
2221		ok.String(*v.LogStreamName)
2222	}
2223
2224	return nil
2225}
2226
2227func awsAwsjson11_serializeOpDocumentDeleteDestinationInput(v *DeleteDestinationInput, value smithyjson.Value) error {
2228	object := value.Object()
2229	defer object.Close()
2230
2231	if v.DestinationName != nil {
2232		ok := object.Key("destinationName")
2233		ok.String(*v.DestinationName)
2234	}
2235
2236	return nil
2237}
2238
2239func awsAwsjson11_serializeOpDocumentDeleteLogGroupInput(v *DeleteLogGroupInput, value smithyjson.Value) error {
2240	object := value.Object()
2241	defer object.Close()
2242
2243	if v.LogGroupName != nil {
2244		ok := object.Key("logGroupName")
2245		ok.String(*v.LogGroupName)
2246	}
2247
2248	return nil
2249}
2250
2251func awsAwsjson11_serializeOpDocumentDeleteLogStreamInput(v *DeleteLogStreamInput, value smithyjson.Value) error {
2252	object := value.Object()
2253	defer object.Close()
2254
2255	if v.LogGroupName != nil {
2256		ok := object.Key("logGroupName")
2257		ok.String(*v.LogGroupName)
2258	}
2259
2260	if v.LogStreamName != nil {
2261		ok := object.Key("logStreamName")
2262		ok.String(*v.LogStreamName)
2263	}
2264
2265	return nil
2266}
2267
2268func awsAwsjson11_serializeOpDocumentDeleteMetricFilterInput(v *DeleteMetricFilterInput, value smithyjson.Value) error {
2269	object := value.Object()
2270	defer object.Close()
2271
2272	if v.FilterName != nil {
2273		ok := object.Key("filterName")
2274		ok.String(*v.FilterName)
2275	}
2276
2277	if v.LogGroupName != nil {
2278		ok := object.Key("logGroupName")
2279		ok.String(*v.LogGroupName)
2280	}
2281
2282	return nil
2283}
2284
2285func awsAwsjson11_serializeOpDocumentDeleteQueryDefinitionInput(v *DeleteQueryDefinitionInput, value smithyjson.Value) error {
2286	object := value.Object()
2287	defer object.Close()
2288
2289	if v.QueryDefinitionId != nil {
2290		ok := object.Key("queryDefinitionId")
2291		ok.String(*v.QueryDefinitionId)
2292	}
2293
2294	return nil
2295}
2296
2297func awsAwsjson11_serializeOpDocumentDeleteResourcePolicyInput(v *DeleteResourcePolicyInput, value smithyjson.Value) error {
2298	object := value.Object()
2299	defer object.Close()
2300
2301	if v.PolicyName != nil {
2302		ok := object.Key("policyName")
2303		ok.String(*v.PolicyName)
2304	}
2305
2306	return nil
2307}
2308
2309func awsAwsjson11_serializeOpDocumentDeleteRetentionPolicyInput(v *DeleteRetentionPolicyInput, value smithyjson.Value) error {
2310	object := value.Object()
2311	defer object.Close()
2312
2313	if v.LogGroupName != nil {
2314		ok := object.Key("logGroupName")
2315		ok.String(*v.LogGroupName)
2316	}
2317
2318	return nil
2319}
2320
2321func awsAwsjson11_serializeOpDocumentDeleteSubscriptionFilterInput(v *DeleteSubscriptionFilterInput, value smithyjson.Value) error {
2322	object := value.Object()
2323	defer object.Close()
2324
2325	if v.FilterName != nil {
2326		ok := object.Key("filterName")
2327		ok.String(*v.FilterName)
2328	}
2329
2330	if v.LogGroupName != nil {
2331		ok := object.Key("logGroupName")
2332		ok.String(*v.LogGroupName)
2333	}
2334
2335	return nil
2336}
2337
2338func awsAwsjson11_serializeOpDocumentDescribeDestinationsInput(v *DescribeDestinationsInput, value smithyjson.Value) error {
2339	object := value.Object()
2340	defer object.Close()
2341
2342	if v.DestinationNamePrefix != nil {
2343		ok := object.Key("DestinationNamePrefix")
2344		ok.String(*v.DestinationNamePrefix)
2345	}
2346
2347	if v.Limit != nil {
2348		ok := object.Key("limit")
2349		ok.Integer(*v.Limit)
2350	}
2351
2352	if v.NextToken != nil {
2353		ok := object.Key("nextToken")
2354		ok.String(*v.NextToken)
2355	}
2356
2357	return nil
2358}
2359
2360func awsAwsjson11_serializeOpDocumentDescribeExportTasksInput(v *DescribeExportTasksInput, value smithyjson.Value) error {
2361	object := value.Object()
2362	defer object.Close()
2363
2364	if v.Limit != nil {
2365		ok := object.Key("limit")
2366		ok.Integer(*v.Limit)
2367	}
2368
2369	if v.NextToken != nil {
2370		ok := object.Key("nextToken")
2371		ok.String(*v.NextToken)
2372	}
2373
2374	if len(v.StatusCode) > 0 {
2375		ok := object.Key("statusCode")
2376		ok.String(string(v.StatusCode))
2377	}
2378
2379	if v.TaskId != nil {
2380		ok := object.Key("taskId")
2381		ok.String(*v.TaskId)
2382	}
2383
2384	return nil
2385}
2386
2387func awsAwsjson11_serializeOpDocumentDescribeLogGroupsInput(v *DescribeLogGroupsInput, value smithyjson.Value) error {
2388	object := value.Object()
2389	defer object.Close()
2390
2391	if v.Limit != nil {
2392		ok := object.Key("limit")
2393		ok.Integer(*v.Limit)
2394	}
2395
2396	if v.LogGroupNamePrefix != nil {
2397		ok := object.Key("logGroupNamePrefix")
2398		ok.String(*v.LogGroupNamePrefix)
2399	}
2400
2401	if v.NextToken != nil {
2402		ok := object.Key("nextToken")
2403		ok.String(*v.NextToken)
2404	}
2405
2406	return nil
2407}
2408
2409func awsAwsjson11_serializeOpDocumentDescribeLogStreamsInput(v *DescribeLogStreamsInput, value smithyjson.Value) error {
2410	object := value.Object()
2411	defer object.Close()
2412
2413	if v.Descending != nil {
2414		ok := object.Key("descending")
2415		ok.Boolean(*v.Descending)
2416	}
2417
2418	if v.Limit != nil {
2419		ok := object.Key("limit")
2420		ok.Integer(*v.Limit)
2421	}
2422
2423	if v.LogGroupName != nil {
2424		ok := object.Key("logGroupName")
2425		ok.String(*v.LogGroupName)
2426	}
2427
2428	if v.LogStreamNamePrefix != nil {
2429		ok := object.Key("logStreamNamePrefix")
2430		ok.String(*v.LogStreamNamePrefix)
2431	}
2432
2433	if v.NextToken != nil {
2434		ok := object.Key("nextToken")
2435		ok.String(*v.NextToken)
2436	}
2437
2438	if len(v.OrderBy) > 0 {
2439		ok := object.Key("orderBy")
2440		ok.String(string(v.OrderBy))
2441	}
2442
2443	return nil
2444}
2445
2446func awsAwsjson11_serializeOpDocumentDescribeMetricFiltersInput(v *DescribeMetricFiltersInput, value smithyjson.Value) error {
2447	object := value.Object()
2448	defer object.Close()
2449
2450	if v.FilterNamePrefix != nil {
2451		ok := object.Key("filterNamePrefix")
2452		ok.String(*v.FilterNamePrefix)
2453	}
2454
2455	if v.Limit != nil {
2456		ok := object.Key("limit")
2457		ok.Integer(*v.Limit)
2458	}
2459
2460	if v.LogGroupName != nil {
2461		ok := object.Key("logGroupName")
2462		ok.String(*v.LogGroupName)
2463	}
2464
2465	if v.MetricName != nil {
2466		ok := object.Key("metricName")
2467		ok.String(*v.MetricName)
2468	}
2469
2470	if v.MetricNamespace != nil {
2471		ok := object.Key("metricNamespace")
2472		ok.String(*v.MetricNamespace)
2473	}
2474
2475	if v.NextToken != nil {
2476		ok := object.Key("nextToken")
2477		ok.String(*v.NextToken)
2478	}
2479
2480	return nil
2481}
2482
2483func awsAwsjson11_serializeOpDocumentDescribeQueriesInput(v *DescribeQueriesInput, value smithyjson.Value) error {
2484	object := value.Object()
2485	defer object.Close()
2486
2487	if v.LogGroupName != nil {
2488		ok := object.Key("logGroupName")
2489		ok.String(*v.LogGroupName)
2490	}
2491
2492	if v.MaxResults != nil {
2493		ok := object.Key("maxResults")
2494		ok.Integer(*v.MaxResults)
2495	}
2496
2497	if v.NextToken != nil {
2498		ok := object.Key("nextToken")
2499		ok.String(*v.NextToken)
2500	}
2501
2502	if len(v.Status) > 0 {
2503		ok := object.Key("status")
2504		ok.String(string(v.Status))
2505	}
2506
2507	return nil
2508}
2509
2510func awsAwsjson11_serializeOpDocumentDescribeQueryDefinitionsInput(v *DescribeQueryDefinitionsInput, value smithyjson.Value) error {
2511	object := value.Object()
2512	defer object.Close()
2513
2514	if v.MaxResults != nil {
2515		ok := object.Key("maxResults")
2516		ok.Integer(*v.MaxResults)
2517	}
2518
2519	if v.NextToken != nil {
2520		ok := object.Key("nextToken")
2521		ok.String(*v.NextToken)
2522	}
2523
2524	if v.QueryDefinitionNamePrefix != nil {
2525		ok := object.Key("queryDefinitionNamePrefix")
2526		ok.String(*v.QueryDefinitionNamePrefix)
2527	}
2528
2529	return nil
2530}
2531
2532func awsAwsjson11_serializeOpDocumentDescribeResourcePoliciesInput(v *DescribeResourcePoliciesInput, value smithyjson.Value) error {
2533	object := value.Object()
2534	defer object.Close()
2535
2536	if v.Limit != nil {
2537		ok := object.Key("limit")
2538		ok.Integer(*v.Limit)
2539	}
2540
2541	if v.NextToken != nil {
2542		ok := object.Key("nextToken")
2543		ok.String(*v.NextToken)
2544	}
2545
2546	return nil
2547}
2548
2549func awsAwsjson11_serializeOpDocumentDescribeSubscriptionFiltersInput(v *DescribeSubscriptionFiltersInput, value smithyjson.Value) error {
2550	object := value.Object()
2551	defer object.Close()
2552
2553	if v.FilterNamePrefix != nil {
2554		ok := object.Key("filterNamePrefix")
2555		ok.String(*v.FilterNamePrefix)
2556	}
2557
2558	if v.Limit != nil {
2559		ok := object.Key("limit")
2560		ok.Integer(*v.Limit)
2561	}
2562
2563	if v.LogGroupName != nil {
2564		ok := object.Key("logGroupName")
2565		ok.String(*v.LogGroupName)
2566	}
2567
2568	if v.NextToken != nil {
2569		ok := object.Key("nextToken")
2570		ok.String(*v.NextToken)
2571	}
2572
2573	return nil
2574}
2575
2576func awsAwsjson11_serializeOpDocumentDisassociateKmsKeyInput(v *DisassociateKmsKeyInput, value smithyjson.Value) error {
2577	object := value.Object()
2578	defer object.Close()
2579
2580	if v.LogGroupName != nil {
2581		ok := object.Key("logGroupName")
2582		ok.String(*v.LogGroupName)
2583	}
2584
2585	return nil
2586}
2587
2588func awsAwsjson11_serializeOpDocumentFilterLogEventsInput(v *FilterLogEventsInput, value smithyjson.Value) error {
2589	object := value.Object()
2590	defer object.Close()
2591
2592	if v.EndTime != nil {
2593		ok := object.Key("endTime")
2594		ok.Long(*v.EndTime)
2595	}
2596
2597	if v.FilterPattern != nil {
2598		ok := object.Key("filterPattern")
2599		ok.String(*v.FilterPattern)
2600	}
2601
2602	if v.Interleaved != nil {
2603		ok := object.Key("interleaved")
2604		ok.Boolean(*v.Interleaved)
2605	}
2606
2607	if v.Limit != nil {
2608		ok := object.Key("limit")
2609		ok.Integer(*v.Limit)
2610	}
2611
2612	if v.LogGroupName != nil {
2613		ok := object.Key("logGroupName")
2614		ok.String(*v.LogGroupName)
2615	}
2616
2617	if v.LogStreamNamePrefix != nil {
2618		ok := object.Key("logStreamNamePrefix")
2619		ok.String(*v.LogStreamNamePrefix)
2620	}
2621
2622	if v.LogStreamNames != nil {
2623		ok := object.Key("logStreamNames")
2624		if err := awsAwsjson11_serializeDocumentInputLogStreamNames(v.LogStreamNames, ok); err != nil {
2625			return err
2626		}
2627	}
2628
2629	if v.NextToken != nil {
2630		ok := object.Key("nextToken")
2631		ok.String(*v.NextToken)
2632	}
2633
2634	if v.StartTime != nil {
2635		ok := object.Key("startTime")
2636		ok.Long(*v.StartTime)
2637	}
2638
2639	return nil
2640}
2641
2642func awsAwsjson11_serializeOpDocumentGetLogEventsInput(v *GetLogEventsInput, value smithyjson.Value) error {
2643	object := value.Object()
2644	defer object.Close()
2645
2646	if v.EndTime != nil {
2647		ok := object.Key("endTime")
2648		ok.Long(*v.EndTime)
2649	}
2650
2651	if v.Limit != nil {
2652		ok := object.Key("limit")
2653		ok.Integer(*v.Limit)
2654	}
2655
2656	if v.LogGroupName != nil {
2657		ok := object.Key("logGroupName")
2658		ok.String(*v.LogGroupName)
2659	}
2660
2661	if v.LogStreamName != nil {
2662		ok := object.Key("logStreamName")
2663		ok.String(*v.LogStreamName)
2664	}
2665
2666	if v.NextToken != nil {
2667		ok := object.Key("nextToken")
2668		ok.String(*v.NextToken)
2669	}
2670
2671	if v.StartFromHead != nil {
2672		ok := object.Key("startFromHead")
2673		ok.Boolean(*v.StartFromHead)
2674	}
2675
2676	if v.StartTime != nil {
2677		ok := object.Key("startTime")
2678		ok.Long(*v.StartTime)
2679	}
2680
2681	return nil
2682}
2683
2684func awsAwsjson11_serializeOpDocumentGetLogGroupFieldsInput(v *GetLogGroupFieldsInput, value smithyjson.Value) error {
2685	object := value.Object()
2686	defer object.Close()
2687
2688	if v.LogGroupName != nil {
2689		ok := object.Key("logGroupName")
2690		ok.String(*v.LogGroupName)
2691	}
2692
2693	if v.Time != nil {
2694		ok := object.Key("time")
2695		ok.Long(*v.Time)
2696	}
2697
2698	return nil
2699}
2700
2701func awsAwsjson11_serializeOpDocumentGetLogRecordInput(v *GetLogRecordInput, value smithyjson.Value) error {
2702	object := value.Object()
2703	defer object.Close()
2704
2705	if v.LogRecordPointer != nil {
2706		ok := object.Key("logRecordPointer")
2707		ok.String(*v.LogRecordPointer)
2708	}
2709
2710	return nil
2711}
2712
2713func awsAwsjson11_serializeOpDocumentGetQueryResultsInput(v *GetQueryResultsInput, value smithyjson.Value) error {
2714	object := value.Object()
2715	defer object.Close()
2716
2717	if v.QueryId != nil {
2718		ok := object.Key("queryId")
2719		ok.String(*v.QueryId)
2720	}
2721
2722	return nil
2723}
2724
2725func awsAwsjson11_serializeOpDocumentListTagsLogGroupInput(v *ListTagsLogGroupInput, value smithyjson.Value) error {
2726	object := value.Object()
2727	defer object.Close()
2728
2729	if v.LogGroupName != nil {
2730		ok := object.Key("logGroupName")
2731		ok.String(*v.LogGroupName)
2732	}
2733
2734	return nil
2735}
2736
2737func awsAwsjson11_serializeOpDocumentPutDestinationInput(v *PutDestinationInput, value smithyjson.Value) error {
2738	object := value.Object()
2739	defer object.Close()
2740
2741	if v.DestinationName != nil {
2742		ok := object.Key("destinationName")
2743		ok.String(*v.DestinationName)
2744	}
2745
2746	if v.RoleArn != nil {
2747		ok := object.Key("roleArn")
2748		ok.String(*v.RoleArn)
2749	}
2750
2751	if v.TargetArn != nil {
2752		ok := object.Key("targetArn")
2753		ok.String(*v.TargetArn)
2754	}
2755
2756	return nil
2757}
2758
2759func awsAwsjson11_serializeOpDocumentPutDestinationPolicyInput(v *PutDestinationPolicyInput, value smithyjson.Value) error {
2760	object := value.Object()
2761	defer object.Close()
2762
2763	if v.AccessPolicy != nil {
2764		ok := object.Key("accessPolicy")
2765		ok.String(*v.AccessPolicy)
2766	}
2767
2768	if v.DestinationName != nil {
2769		ok := object.Key("destinationName")
2770		ok.String(*v.DestinationName)
2771	}
2772
2773	return nil
2774}
2775
2776func awsAwsjson11_serializeOpDocumentPutLogEventsInput(v *PutLogEventsInput, value smithyjson.Value) error {
2777	object := value.Object()
2778	defer object.Close()
2779
2780	if v.LogEvents != nil {
2781		ok := object.Key("logEvents")
2782		if err := awsAwsjson11_serializeDocumentInputLogEvents(v.LogEvents, ok); err != nil {
2783			return err
2784		}
2785	}
2786
2787	if v.LogGroupName != nil {
2788		ok := object.Key("logGroupName")
2789		ok.String(*v.LogGroupName)
2790	}
2791
2792	if v.LogStreamName != nil {
2793		ok := object.Key("logStreamName")
2794		ok.String(*v.LogStreamName)
2795	}
2796
2797	if v.SequenceToken != nil {
2798		ok := object.Key("sequenceToken")
2799		ok.String(*v.SequenceToken)
2800	}
2801
2802	return nil
2803}
2804
2805func awsAwsjson11_serializeOpDocumentPutMetricFilterInput(v *PutMetricFilterInput, value smithyjson.Value) error {
2806	object := value.Object()
2807	defer object.Close()
2808
2809	if v.FilterName != nil {
2810		ok := object.Key("filterName")
2811		ok.String(*v.FilterName)
2812	}
2813
2814	if v.FilterPattern != nil {
2815		ok := object.Key("filterPattern")
2816		ok.String(*v.FilterPattern)
2817	}
2818
2819	if v.LogGroupName != nil {
2820		ok := object.Key("logGroupName")
2821		ok.String(*v.LogGroupName)
2822	}
2823
2824	if v.MetricTransformations != nil {
2825		ok := object.Key("metricTransformations")
2826		if err := awsAwsjson11_serializeDocumentMetricTransformations(v.MetricTransformations, ok); err != nil {
2827			return err
2828		}
2829	}
2830
2831	return nil
2832}
2833
2834func awsAwsjson11_serializeOpDocumentPutQueryDefinitionInput(v *PutQueryDefinitionInput, value smithyjson.Value) error {
2835	object := value.Object()
2836	defer object.Close()
2837
2838	if v.LogGroupNames != nil {
2839		ok := object.Key("logGroupNames")
2840		if err := awsAwsjson11_serializeDocumentLogGroupNames(v.LogGroupNames, ok); err != nil {
2841			return err
2842		}
2843	}
2844
2845	if v.Name != nil {
2846		ok := object.Key("name")
2847		ok.String(*v.Name)
2848	}
2849
2850	if v.QueryDefinitionId != nil {
2851		ok := object.Key("queryDefinitionId")
2852		ok.String(*v.QueryDefinitionId)
2853	}
2854
2855	if v.QueryString != nil {
2856		ok := object.Key("queryString")
2857		ok.String(*v.QueryString)
2858	}
2859
2860	return nil
2861}
2862
2863func awsAwsjson11_serializeOpDocumentPutResourcePolicyInput(v *PutResourcePolicyInput, value smithyjson.Value) error {
2864	object := value.Object()
2865	defer object.Close()
2866
2867	if v.PolicyDocument != nil {
2868		ok := object.Key("policyDocument")
2869		ok.String(*v.PolicyDocument)
2870	}
2871
2872	if v.PolicyName != nil {
2873		ok := object.Key("policyName")
2874		ok.String(*v.PolicyName)
2875	}
2876
2877	return nil
2878}
2879
2880func awsAwsjson11_serializeOpDocumentPutRetentionPolicyInput(v *PutRetentionPolicyInput, value smithyjson.Value) error {
2881	object := value.Object()
2882	defer object.Close()
2883
2884	if v.LogGroupName != nil {
2885		ok := object.Key("logGroupName")
2886		ok.String(*v.LogGroupName)
2887	}
2888
2889	if v.RetentionInDays != nil {
2890		ok := object.Key("retentionInDays")
2891		ok.Integer(*v.RetentionInDays)
2892	}
2893
2894	return nil
2895}
2896
2897func awsAwsjson11_serializeOpDocumentPutSubscriptionFilterInput(v *PutSubscriptionFilterInput, value smithyjson.Value) error {
2898	object := value.Object()
2899	defer object.Close()
2900
2901	if v.DestinationArn != nil {
2902		ok := object.Key("destinationArn")
2903		ok.String(*v.DestinationArn)
2904	}
2905
2906	if len(v.Distribution) > 0 {
2907		ok := object.Key("distribution")
2908		ok.String(string(v.Distribution))
2909	}
2910
2911	if v.FilterName != nil {
2912		ok := object.Key("filterName")
2913		ok.String(*v.FilterName)
2914	}
2915
2916	if v.FilterPattern != nil {
2917		ok := object.Key("filterPattern")
2918		ok.String(*v.FilterPattern)
2919	}
2920
2921	if v.LogGroupName != nil {
2922		ok := object.Key("logGroupName")
2923		ok.String(*v.LogGroupName)
2924	}
2925
2926	if v.RoleArn != nil {
2927		ok := object.Key("roleArn")
2928		ok.String(*v.RoleArn)
2929	}
2930
2931	return nil
2932}
2933
2934func awsAwsjson11_serializeOpDocumentStartQueryInput(v *StartQueryInput, value smithyjson.Value) error {
2935	object := value.Object()
2936	defer object.Close()
2937
2938	if v.EndTime != nil {
2939		ok := object.Key("endTime")
2940		ok.Long(*v.EndTime)
2941	}
2942
2943	if v.Limit != nil {
2944		ok := object.Key("limit")
2945		ok.Integer(*v.Limit)
2946	}
2947
2948	if v.LogGroupName != nil {
2949		ok := object.Key("logGroupName")
2950		ok.String(*v.LogGroupName)
2951	}
2952
2953	if v.LogGroupNames != nil {
2954		ok := object.Key("logGroupNames")
2955		if err := awsAwsjson11_serializeDocumentLogGroupNames(v.LogGroupNames, ok); err != nil {
2956			return err
2957		}
2958	}
2959
2960	if v.QueryString != nil {
2961		ok := object.Key("queryString")
2962		ok.String(*v.QueryString)
2963	}
2964
2965	if v.StartTime != nil {
2966		ok := object.Key("startTime")
2967		ok.Long(*v.StartTime)
2968	}
2969
2970	return nil
2971}
2972
2973func awsAwsjson11_serializeOpDocumentStopQueryInput(v *StopQueryInput, value smithyjson.Value) error {
2974	object := value.Object()
2975	defer object.Close()
2976
2977	if v.QueryId != nil {
2978		ok := object.Key("queryId")
2979		ok.String(*v.QueryId)
2980	}
2981
2982	return nil
2983}
2984
2985func awsAwsjson11_serializeOpDocumentTagLogGroupInput(v *TagLogGroupInput, value smithyjson.Value) error {
2986	object := value.Object()
2987	defer object.Close()
2988
2989	if v.LogGroupName != nil {
2990		ok := object.Key("logGroupName")
2991		ok.String(*v.LogGroupName)
2992	}
2993
2994	if v.Tags != nil {
2995		ok := object.Key("tags")
2996		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2997			return err
2998		}
2999	}
3000
3001	return nil
3002}
3003
3004func awsAwsjson11_serializeOpDocumentTestMetricFilterInput(v *TestMetricFilterInput, value smithyjson.Value) error {
3005	object := value.Object()
3006	defer object.Close()
3007
3008	if v.FilterPattern != nil {
3009		ok := object.Key("filterPattern")
3010		ok.String(*v.FilterPattern)
3011	}
3012
3013	if v.LogEventMessages != nil {
3014		ok := object.Key("logEventMessages")
3015		if err := awsAwsjson11_serializeDocumentTestEventMessages(v.LogEventMessages, ok); err != nil {
3016			return err
3017		}
3018	}
3019
3020	return nil
3021}
3022
3023func awsAwsjson11_serializeOpDocumentUntagLogGroupInput(v *UntagLogGroupInput, value smithyjson.Value) error {
3024	object := value.Object()
3025	defer object.Close()
3026
3027	if v.LogGroupName != nil {
3028		ok := object.Key("logGroupName")
3029		ok.String(*v.LogGroupName)
3030	}
3031
3032	if v.Tags != nil {
3033		ok := object.Key("tags")
3034		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3035			return err
3036		}
3037	}
3038
3039	return nil
3040}
3041