serializers.go raw
1 // Code generated by smithy-go-codegen DO NOT EDIT.
2
3 package sts
4
5 import (
6 "bytes"
7 "context"
8 "fmt"
9 "github.com/aws/aws-sdk-go-v2/aws/protocol/query"
10 "github.com/aws/aws-sdk-go-v2/service/sts/types"
11 smithy "github.com/aws/smithy-go"
12 "github.com/aws/smithy-go/encoding/httpbinding"
13 "github.com/aws/smithy-go/middleware"
14 "github.com/aws/smithy-go/tracing"
15 smithyhttp "github.com/aws/smithy-go/transport/http"
16 "path"
17 )
18
19 type awsAwsquery_serializeOpAssumeRole struct {
20 }
21
22 func (*awsAwsquery_serializeOpAssumeRole) ID() string {
23 return "OperationSerializer"
24 }
25
26 func (m *awsAwsquery_serializeOpAssumeRole) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
27 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
28 ) {
29 _, span := tracing.StartSpan(ctx, "OperationSerializer")
30 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
31 defer endTimer()
32 defer span.End()
33 request, ok := in.Request.(*smithyhttp.Request)
34 if !ok {
35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
36 }
37
38 input, ok := in.Parameters.(*AssumeRoleInput)
39 _ = input
40 if !ok {
41 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
42 }
43
44 operationPath := "/"
45 if len(request.Request.URL.Path) == 0 {
46 request.Request.URL.Path = operationPath
47 } else {
48 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
49 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
50 request.Request.URL.Path += "/"
51 }
52 }
53 request.Request.Method = "POST"
54 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
55 if err != nil {
56 return out, metadata, &smithy.SerializationError{Err: err}
57 }
58 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
59
60 bodyWriter := bytes.NewBuffer(nil)
61 bodyEncoder := query.NewEncoder(bodyWriter)
62 body := bodyEncoder.Object()
63 body.Key("Action").String("AssumeRole")
64 body.Key("Version").String("2011-06-15")
65
66 if err := awsAwsquery_serializeOpDocumentAssumeRoleInput(input, bodyEncoder.Value); err != nil {
67 return out, metadata, &smithy.SerializationError{Err: err}
68 }
69
70 err = bodyEncoder.Encode()
71 if err != nil {
72 return out, metadata, &smithy.SerializationError{Err: err}
73 }
74
75 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
76 return out, metadata, &smithy.SerializationError{Err: err}
77 }
78
79 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
80 return out, metadata, &smithy.SerializationError{Err: err}
81 }
82 in.Request = request
83
84 endTimer()
85 span.End()
86 return next.HandleSerialize(ctx, in)
87 }
88
89 type awsAwsquery_serializeOpAssumeRoleWithSAML struct {
90 }
91
92 func (*awsAwsquery_serializeOpAssumeRoleWithSAML) ID() string {
93 return "OperationSerializer"
94 }
95
96 func (m *awsAwsquery_serializeOpAssumeRoleWithSAML) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
97 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
98 ) {
99 _, span := tracing.StartSpan(ctx, "OperationSerializer")
100 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
101 defer endTimer()
102 defer span.End()
103 request, ok := in.Request.(*smithyhttp.Request)
104 if !ok {
105 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
106 }
107
108 input, ok := in.Parameters.(*AssumeRoleWithSAMLInput)
109 _ = input
110 if !ok {
111 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
112 }
113
114 operationPath := "/"
115 if len(request.Request.URL.Path) == 0 {
116 request.Request.URL.Path = operationPath
117 } else {
118 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
119 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
120 request.Request.URL.Path += "/"
121 }
122 }
123 request.Request.Method = "POST"
124 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
125 if err != nil {
126 return out, metadata, &smithy.SerializationError{Err: err}
127 }
128 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
129
130 bodyWriter := bytes.NewBuffer(nil)
131 bodyEncoder := query.NewEncoder(bodyWriter)
132 body := bodyEncoder.Object()
133 body.Key("Action").String("AssumeRoleWithSAML")
134 body.Key("Version").String("2011-06-15")
135
136 if err := awsAwsquery_serializeOpDocumentAssumeRoleWithSAMLInput(input, bodyEncoder.Value); err != nil {
137 return out, metadata, &smithy.SerializationError{Err: err}
138 }
139
140 err = bodyEncoder.Encode()
141 if err != nil {
142 return out, metadata, &smithy.SerializationError{Err: err}
143 }
144
145 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
146 return out, metadata, &smithy.SerializationError{Err: err}
147 }
148
149 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
150 return out, metadata, &smithy.SerializationError{Err: err}
151 }
152 in.Request = request
153
154 endTimer()
155 span.End()
156 return next.HandleSerialize(ctx, in)
157 }
158
159 type awsAwsquery_serializeOpAssumeRoleWithWebIdentity struct {
160 }
161
162 func (*awsAwsquery_serializeOpAssumeRoleWithWebIdentity) ID() string {
163 return "OperationSerializer"
164 }
165
166 func (m *awsAwsquery_serializeOpAssumeRoleWithWebIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
167 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
168 ) {
169 _, span := tracing.StartSpan(ctx, "OperationSerializer")
170 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
171 defer endTimer()
172 defer span.End()
173 request, ok := in.Request.(*smithyhttp.Request)
174 if !ok {
175 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
176 }
177
178 input, ok := in.Parameters.(*AssumeRoleWithWebIdentityInput)
179 _ = input
180 if !ok {
181 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
182 }
183
184 operationPath := "/"
185 if len(request.Request.URL.Path) == 0 {
186 request.Request.URL.Path = operationPath
187 } else {
188 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
189 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
190 request.Request.URL.Path += "/"
191 }
192 }
193 request.Request.Method = "POST"
194 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
195 if err != nil {
196 return out, metadata, &smithy.SerializationError{Err: err}
197 }
198 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
199
200 bodyWriter := bytes.NewBuffer(nil)
201 bodyEncoder := query.NewEncoder(bodyWriter)
202 body := bodyEncoder.Object()
203 body.Key("Action").String("AssumeRoleWithWebIdentity")
204 body.Key("Version").String("2011-06-15")
205
206 if err := awsAwsquery_serializeOpDocumentAssumeRoleWithWebIdentityInput(input, bodyEncoder.Value); err != nil {
207 return out, metadata, &smithy.SerializationError{Err: err}
208 }
209
210 err = bodyEncoder.Encode()
211 if err != nil {
212 return out, metadata, &smithy.SerializationError{Err: err}
213 }
214
215 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
216 return out, metadata, &smithy.SerializationError{Err: err}
217 }
218
219 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
220 return out, metadata, &smithy.SerializationError{Err: err}
221 }
222 in.Request = request
223
224 endTimer()
225 span.End()
226 return next.HandleSerialize(ctx, in)
227 }
228
229 type awsAwsquery_serializeOpAssumeRoot struct {
230 }
231
232 func (*awsAwsquery_serializeOpAssumeRoot) ID() string {
233 return "OperationSerializer"
234 }
235
236 func (m *awsAwsquery_serializeOpAssumeRoot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
237 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
238 ) {
239 _, span := tracing.StartSpan(ctx, "OperationSerializer")
240 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
241 defer endTimer()
242 defer span.End()
243 request, ok := in.Request.(*smithyhttp.Request)
244 if !ok {
245 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
246 }
247
248 input, ok := in.Parameters.(*AssumeRootInput)
249 _ = input
250 if !ok {
251 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
252 }
253
254 operationPath := "/"
255 if len(request.Request.URL.Path) == 0 {
256 request.Request.URL.Path = operationPath
257 } else {
258 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
259 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
260 request.Request.URL.Path += "/"
261 }
262 }
263 request.Request.Method = "POST"
264 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
265 if err != nil {
266 return out, metadata, &smithy.SerializationError{Err: err}
267 }
268 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
269
270 bodyWriter := bytes.NewBuffer(nil)
271 bodyEncoder := query.NewEncoder(bodyWriter)
272 body := bodyEncoder.Object()
273 body.Key("Action").String("AssumeRoot")
274 body.Key("Version").String("2011-06-15")
275
276 if err := awsAwsquery_serializeOpDocumentAssumeRootInput(input, bodyEncoder.Value); err != nil {
277 return out, metadata, &smithy.SerializationError{Err: err}
278 }
279
280 err = bodyEncoder.Encode()
281 if err != nil {
282 return out, metadata, &smithy.SerializationError{Err: err}
283 }
284
285 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
286 return out, metadata, &smithy.SerializationError{Err: err}
287 }
288
289 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
290 return out, metadata, &smithy.SerializationError{Err: err}
291 }
292 in.Request = request
293
294 endTimer()
295 span.End()
296 return next.HandleSerialize(ctx, in)
297 }
298
299 type awsAwsquery_serializeOpDecodeAuthorizationMessage struct {
300 }
301
302 func (*awsAwsquery_serializeOpDecodeAuthorizationMessage) ID() string {
303 return "OperationSerializer"
304 }
305
306 func (m *awsAwsquery_serializeOpDecodeAuthorizationMessage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
307 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
308 ) {
309 _, span := tracing.StartSpan(ctx, "OperationSerializer")
310 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
311 defer endTimer()
312 defer span.End()
313 request, ok := in.Request.(*smithyhttp.Request)
314 if !ok {
315 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
316 }
317
318 input, ok := in.Parameters.(*DecodeAuthorizationMessageInput)
319 _ = input
320 if !ok {
321 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
322 }
323
324 operationPath := "/"
325 if len(request.Request.URL.Path) == 0 {
326 request.Request.URL.Path = operationPath
327 } else {
328 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
329 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
330 request.Request.URL.Path += "/"
331 }
332 }
333 request.Request.Method = "POST"
334 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
335 if err != nil {
336 return out, metadata, &smithy.SerializationError{Err: err}
337 }
338 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
339
340 bodyWriter := bytes.NewBuffer(nil)
341 bodyEncoder := query.NewEncoder(bodyWriter)
342 body := bodyEncoder.Object()
343 body.Key("Action").String("DecodeAuthorizationMessage")
344 body.Key("Version").String("2011-06-15")
345
346 if err := awsAwsquery_serializeOpDocumentDecodeAuthorizationMessageInput(input, bodyEncoder.Value); err != nil {
347 return out, metadata, &smithy.SerializationError{Err: err}
348 }
349
350 err = bodyEncoder.Encode()
351 if err != nil {
352 return out, metadata, &smithy.SerializationError{Err: err}
353 }
354
355 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
356 return out, metadata, &smithy.SerializationError{Err: err}
357 }
358
359 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
360 return out, metadata, &smithy.SerializationError{Err: err}
361 }
362 in.Request = request
363
364 endTimer()
365 span.End()
366 return next.HandleSerialize(ctx, in)
367 }
368
369 type awsAwsquery_serializeOpGetAccessKeyInfo struct {
370 }
371
372 func (*awsAwsquery_serializeOpGetAccessKeyInfo) ID() string {
373 return "OperationSerializer"
374 }
375
376 func (m *awsAwsquery_serializeOpGetAccessKeyInfo) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
377 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
378 ) {
379 _, span := tracing.StartSpan(ctx, "OperationSerializer")
380 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
381 defer endTimer()
382 defer span.End()
383 request, ok := in.Request.(*smithyhttp.Request)
384 if !ok {
385 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
386 }
387
388 input, ok := in.Parameters.(*GetAccessKeyInfoInput)
389 _ = input
390 if !ok {
391 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
392 }
393
394 operationPath := "/"
395 if len(request.Request.URL.Path) == 0 {
396 request.Request.URL.Path = operationPath
397 } else {
398 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
399 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
400 request.Request.URL.Path += "/"
401 }
402 }
403 request.Request.Method = "POST"
404 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
405 if err != nil {
406 return out, metadata, &smithy.SerializationError{Err: err}
407 }
408 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
409
410 bodyWriter := bytes.NewBuffer(nil)
411 bodyEncoder := query.NewEncoder(bodyWriter)
412 body := bodyEncoder.Object()
413 body.Key("Action").String("GetAccessKeyInfo")
414 body.Key("Version").String("2011-06-15")
415
416 if err := awsAwsquery_serializeOpDocumentGetAccessKeyInfoInput(input, bodyEncoder.Value); err != nil {
417 return out, metadata, &smithy.SerializationError{Err: err}
418 }
419
420 err = bodyEncoder.Encode()
421 if err != nil {
422 return out, metadata, &smithy.SerializationError{Err: err}
423 }
424
425 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
426 return out, metadata, &smithy.SerializationError{Err: err}
427 }
428
429 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
430 return out, metadata, &smithy.SerializationError{Err: err}
431 }
432 in.Request = request
433
434 endTimer()
435 span.End()
436 return next.HandleSerialize(ctx, in)
437 }
438
439 type awsAwsquery_serializeOpGetCallerIdentity struct {
440 }
441
442 func (*awsAwsquery_serializeOpGetCallerIdentity) ID() string {
443 return "OperationSerializer"
444 }
445
446 func (m *awsAwsquery_serializeOpGetCallerIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
447 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
448 ) {
449 _, span := tracing.StartSpan(ctx, "OperationSerializer")
450 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
451 defer endTimer()
452 defer span.End()
453 request, ok := in.Request.(*smithyhttp.Request)
454 if !ok {
455 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
456 }
457
458 input, ok := in.Parameters.(*GetCallerIdentityInput)
459 _ = input
460 if !ok {
461 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
462 }
463
464 operationPath := "/"
465 if len(request.Request.URL.Path) == 0 {
466 request.Request.URL.Path = operationPath
467 } else {
468 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
469 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
470 request.Request.URL.Path += "/"
471 }
472 }
473 request.Request.Method = "POST"
474 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
475 if err != nil {
476 return out, metadata, &smithy.SerializationError{Err: err}
477 }
478 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
479
480 bodyWriter := bytes.NewBuffer(nil)
481 bodyEncoder := query.NewEncoder(bodyWriter)
482 body := bodyEncoder.Object()
483 body.Key("Action").String("GetCallerIdentity")
484 body.Key("Version").String("2011-06-15")
485
486 err = bodyEncoder.Encode()
487 if err != nil {
488 return out, metadata, &smithy.SerializationError{Err: err}
489 }
490
491 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
492 return out, metadata, &smithy.SerializationError{Err: err}
493 }
494
495 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
496 return out, metadata, &smithy.SerializationError{Err: err}
497 }
498 in.Request = request
499
500 endTimer()
501 span.End()
502 return next.HandleSerialize(ctx, in)
503 }
504
505 type awsAwsquery_serializeOpGetDelegatedAccessToken struct {
506 }
507
508 func (*awsAwsquery_serializeOpGetDelegatedAccessToken) ID() string {
509 return "OperationSerializer"
510 }
511
512 func (m *awsAwsquery_serializeOpGetDelegatedAccessToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
513 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
514 ) {
515 _, span := tracing.StartSpan(ctx, "OperationSerializer")
516 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
517 defer endTimer()
518 defer span.End()
519 request, ok := in.Request.(*smithyhttp.Request)
520 if !ok {
521 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
522 }
523
524 input, ok := in.Parameters.(*GetDelegatedAccessTokenInput)
525 _ = input
526 if !ok {
527 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
528 }
529
530 operationPath := "/"
531 if len(request.Request.URL.Path) == 0 {
532 request.Request.URL.Path = operationPath
533 } else {
534 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
535 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
536 request.Request.URL.Path += "/"
537 }
538 }
539 request.Request.Method = "POST"
540 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
541 if err != nil {
542 return out, metadata, &smithy.SerializationError{Err: err}
543 }
544 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
545
546 bodyWriter := bytes.NewBuffer(nil)
547 bodyEncoder := query.NewEncoder(bodyWriter)
548 body := bodyEncoder.Object()
549 body.Key("Action").String("GetDelegatedAccessToken")
550 body.Key("Version").String("2011-06-15")
551
552 if err := awsAwsquery_serializeOpDocumentGetDelegatedAccessTokenInput(input, bodyEncoder.Value); err != nil {
553 return out, metadata, &smithy.SerializationError{Err: err}
554 }
555
556 err = bodyEncoder.Encode()
557 if err != nil {
558 return out, metadata, &smithy.SerializationError{Err: err}
559 }
560
561 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
562 return out, metadata, &smithy.SerializationError{Err: err}
563 }
564
565 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
566 return out, metadata, &smithy.SerializationError{Err: err}
567 }
568 in.Request = request
569
570 endTimer()
571 span.End()
572 return next.HandleSerialize(ctx, in)
573 }
574
575 type awsAwsquery_serializeOpGetFederationToken struct {
576 }
577
578 func (*awsAwsquery_serializeOpGetFederationToken) ID() string {
579 return "OperationSerializer"
580 }
581
582 func (m *awsAwsquery_serializeOpGetFederationToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
583 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
584 ) {
585 _, span := tracing.StartSpan(ctx, "OperationSerializer")
586 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
587 defer endTimer()
588 defer span.End()
589 request, ok := in.Request.(*smithyhttp.Request)
590 if !ok {
591 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
592 }
593
594 input, ok := in.Parameters.(*GetFederationTokenInput)
595 _ = input
596 if !ok {
597 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
598 }
599
600 operationPath := "/"
601 if len(request.Request.URL.Path) == 0 {
602 request.Request.URL.Path = operationPath
603 } else {
604 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
605 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
606 request.Request.URL.Path += "/"
607 }
608 }
609 request.Request.Method = "POST"
610 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
611 if err != nil {
612 return out, metadata, &smithy.SerializationError{Err: err}
613 }
614 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
615
616 bodyWriter := bytes.NewBuffer(nil)
617 bodyEncoder := query.NewEncoder(bodyWriter)
618 body := bodyEncoder.Object()
619 body.Key("Action").String("GetFederationToken")
620 body.Key("Version").String("2011-06-15")
621
622 if err := awsAwsquery_serializeOpDocumentGetFederationTokenInput(input, bodyEncoder.Value); err != nil {
623 return out, metadata, &smithy.SerializationError{Err: err}
624 }
625
626 err = bodyEncoder.Encode()
627 if err != nil {
628 return out, metadata, &smithy.SerializationError{Err: err}
629 }
630
631 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
632 return out, metadata, &smithy.SerializationError{Err: err}
633 }
634
635 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
636 return out, metadata, &smithy.SerializationError{Err: err}
637 }
638 in.Request = request
639
640 endTimer()
641 span.End()
642 return next.HandleSerialize(ctx, in)
643 }
644
645 type awsAwsquery_serializeOpGetSessionToken struct {
646 }
647
648 func (*awsAwsquery_serializeOpGetSessionToken) ID() string {
649 return "OperationSerializer"
650 }
651
652 func (m *awsAwsquery_serializeOpGetSessionToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
653 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
654 ) {
655 _, span := tracing.StartSpan(ctx, "OperationSerializer")
656 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
657 defer endTimer()
658 defer span.End()
659 request, ok := in.Request.(*smithyhttp.Request)
660 if !ok {
661 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
662 }
663
664 input, ok := in.Parameters.(*GetSessionTokenInput)
665 _ = input
666 if !ok {
667 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
668 }
669
670 operationPath := "/"
671 if len(request.Request.URL.Path) == 0 {
672 request.Request.URL.Path = operationPath
673 } else {
674 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
675 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
676 request.Request.URL.Path += "/"
677 }
678 }
679 request.Request.Method = "POST"
680 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
681 if err != nil {
682 return out, metadata, &smithy.SerializationError{Err: err}
683 }
684 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
685
686 bodyWriter := bytes.NewBuffer(nil)
687 bodyEncoder := query.NewEncoder(bodyWriter)
688 body := bodyEncoder.Object()
689 body.Key("Action").String("GetSessionToken")
690 body.Key("Version").String("2011-06-15")
691
692 if err := awsAwsquery_serializeOpDocumentGetSessionTokenInput(input, bodyEncoder.Value); err != nil {
693 return out, metadata, &smithy.SerializationError{Err: err}
694 }
695
696 err = bodyEncoder.Encode()
697 if err != nil {
698 return out, metadata, &smithy.SerializationError{Err: err}
699 }
700
701 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
702 return out, metadata, &smithy.SerializationError{Err: err}
703 }
704
705 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
706 return out, metadata, &smithy.SerializationError{Err: err}
707 }
708 in.Request = request
709
710 endTimer()
711 span.End()
712 return next.HandleSerialize(ctx, in)
713 }
714
715 type awsAwsquery_serializeOpGetWebIdentityToken struct {
716 }
717
718 func (*awsAwsquery_serializeOpGetWebIdentityToken) ID() string {
719 return "OperationSerializer"
720 }
721
722 func (m *awsAwsquery_serializeOpGetWebIdentityToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
723 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
724 ) {
725 _, span := tracing.StartSpan(ctx, "OperationSerializer")
726 endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
727 defer endTimer()
728 defer span.End()
729 request, ok := in.Request.(*smithyhttp.Request)
730 if !ok {
731 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
732 }
733
734 input, ok := in.Parameters.(*GetWebIdentityTokenInput)
735 _ = input
736 if !ok {
737 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
738 }
739
740 operationPath := "/"
741 if len(request.Request.URL.Path) == 0 {
742 request.Request.URL.Path = operationPath
743 } else {
744 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
745 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
746 request.Request.URL.Path += "/"
747 }
748 }
749 request.Request.Method = "POST"
750 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
751 if err != nil {
752 return out, metadata, &smithy.SerializationError{Err: err}
753 }
754 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
755
756 bodyWriter := bytes.NewBuffer(nil)
757 bodyEncoder := query.NewEncoder(bodyWriter)
758 body := bodyEncoder.Object()
759 body.Key("Action").String("GetWebIdentityToken")
760 body.Key("Version").String("2011-06-15")
761
762 if err := awsAwsquery_serializeOpDocumentGetWebIdentityTokenInput(input, bodyEncoder.Value); err != nil {
763 return out, metadata, &smithy.SerializationError{Err: err}
764 }
765
766 err = bodyEncoder.Encode()
767 if err != nil {
768 return out, metadata, &smithy.SerializationError{Err: err}
769 }
770
771 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
772 return out, metadata, &smithy.SerializationError{Err: err}
773 }
774
775 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
776 return out, metadata, &smithy.SerializationError{Err: err}
777 }
778 in.Request = request
779
780 endTimer()
781 span.End()
782 return next.HandleSerialize(ctx, in)
783 }
784 func awsAwsquery_serializeDocumentPolicyDescriptorListType(v []types.PolicyDescriptorType, value query.Value) error {
785 array := value.Array("member")
786
787 for i := range v {
788 av := array.Value()
789 if err := awsAwsquery_serializeDocumentPolicyDescriptorType(&v[i], av); err != nil {
790 return err
791 }
792 }
793 return nil
794 }
795
796 func awsAwsquery_serializeDocumentPolicyDescriptorType(v *types.PolicyDescriptorType, value query.Value) error {
797 object := value.Object()
798 _ = object
799
800 if v.Arn != nil {
801 objectKey := object.Key("arn")
802 objectKey.String(*v.Arn)
803 }
804
805 return nil
806 }
807
808 func awsAwsquery_serializeDocumentProvidedContext(v *types.ProvidedContext, value query.Value) error {
809 object := value.Object()
810 _ = object
811
812 if v.ContextAssertion != nil {
813 objectKey := object.Key("ContextAssertion")
814 objectKey.String(*v.ContextAssertion)
815 }
816
817 if v.ProviderArn != nil {
818 objectKey := object.Key("ProviderArn")
819 objectKey.String(*v.ProviderArn)
820 }
821
822 return nil
823 }
824
825 func awsAwsquery_serializeDocumentProvidedContextsListType(v []types.ProvidedContext, value query.Value) error {
826 array := value.Array("member")
827
828 for i := range v {
829 av := array.Value()
830 if err := awsAwsquery_serializeDocumentProvidedContext(&v[i], av); err != nil {
831 return err
832 }
833 }
834 return nil
835 }
836
837 func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error {
838 object := value.Object()
839 _ = object
840
841 if v.Key != nil {
842 objectKey := object.Key("Key")
843 objectKey.String(*v.Key)
844 }
845
846 if v.Value != nil {
847 objectKey := object.Key("Value")
848 objectKey.String(*v.Value)
849 }
850
851 return nil
852 }
853
854 func awsAwsquery_serializeDocumentTagKeyListType(v []string, value query.Value) error {
855 array := value.Array("member")
856
857 for i := range v {
858 av := array.Value()
859 av.String(v[i])
860 }
861 return nil
862 }
863
864 func awsAwsquery_serializeDocumentTagListType(v []types.Tag, value query.Value) error {
865 array := value.Array("member")
866
867 for i := range v {
868 av := array.Value()
869 if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil {
870 return err
871 }
872 }
873 return nil
874 }
875
876 func awsAwsquery_serializeDocumentWebIdentityTokenAudienceListType(v []string, value query.Value) error {
877 array := value.Array("member")
878
879 for i := range v {
880 av := array.Value()
881 av.String(v[i])
882 }
883 return nil
884 }
885
886 func awsAwsquery_serializeOpDocumentAssumeRoleInput(v *AssumeRoleInput, value query.Value) error {
887 object := value.Object()
888 _ = object
889
890 if v.DurationSeconds != nil {
891 objectKey := object.Key("DurationSeconds")
892 objectKey.Integer(*v.DurationSeconds)
893 }
894
895 if v.ExternalId != nil {
896 objectKey := object.Key("ExternalId")
897 objectKey.String(*v.ExternalId)
898 }
899
900 if v.Policy != nil {
901 objectKey := object.Key("Policy")
902 objectKey.String(*v.Policy)
903 }
904
905 if v.PolicyArns != nil {
906 objectKey := object.Key("PolicyArns")
907 if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
908 return err
909 }
910 }
911
912 if v.ProvidedContexts != nil {
913 objectKey := object.Key("ProvidedContexts")
914 if err := awsAwsquery_serializeDocumentProvidedContextsListType(v.ProvidedContexts, objectKey); err != nil {
915 return err
916 }
917 }
918
919 if v.RoleArn != nil {
920 objectKey := object.Key("RoleArn")
921 objectKey.String(*v.RoleArn)
922 }
923
924 if v.RoleSessionName != nil {
925 objectKey := object.Key("RoleSessionName")
926 objectKey.String(*v.RoleSessionName)
927 }
928
929 if v.SerialNumber != nil {
930 objectKey := object.Key("SerialNumber")
931 objectKey.String(*v.SerialNumber)
932 }
933
934 if v.SourceIdentity != nil {
935 objectKey := object.Key("SourceIdentity")
936 objectKey.String(*v.SourceIdentity)
937 }
938
939 if v.Tags != nil {
940 objectKey := object.Key("Tags")
941 if err := awsAwsquery_serializeDocumentTagListType(v.Tags, objectKey); err != nil {
942 return err
943 }
944 }
945
946 if v.TokenCode != nil {
947 objectKey := object.Key("TokenCode")
948 objectKey.String(*v.TokenCode)
949 }
950
951 if v.TransitiveTagKeys != nil {
952 objectKey := object.Key("TransitiveTagKeys")
953 if err := awsAwsquery_serializeDocumentTagKeyListType(v.TransitiveTagKeys, objectKey); err != nil {
954 return err
955 }
956 }
957
958 return nil
959 }
960
961 func awsAwsquery_serializeOpDocumentAssumeRoleWithSAMLInput(v *AssumeRoleWithSAMLInput, value query.Value) error {
962 object := value.Object()
963 _ = object
964
965 if v.DurationSeconds != nil {
966 objectKey := object.Key("DurationSeconds")
967 objectKey.Integer(*v.DurationSeconds)
968 }
969
970 if v.Policy != nil {
971 objectKey := object.Key("Policy")
972 objectKey.String(*v.Policy)
973 }
974
975 if v.PolicyArns != nil {
976 objectKey := object.Key("PolicyArns")
977 if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
978 return err
979 }
980 }
981
982 if v.PrincipalArn != nil {
983 objectKey := object.Key("PrincipalArn")
984 objectKey.String(*v.PrincipalArn)
985 }
986
987 if v.RoleArn != nil {
988 objectKey := object.Key("RoleArn")
989 objectKey.String(*v.RoleArn)
990 }
991
992 if v.SAMLAssertion != nil {
993 objectKey := object.Key("SAMLAssertion")
994 objectKey.String(*v.SAMLAssertion)
995 }
996
997 return nil
998 }
999
1000 func awsAwsquery_serializeOpDocumentAssumeRoleWithWebIdentityInput(v *AssumeRoleWithWebIdentityInput, value query.Value) error {
1001 object := value.Object()
1002 _ = object
1003
1004 if v.DurationSeconds != nil {
1005 objectKey := object.Key("DurationSeconds")
1006 objectKey.Integer(*v.DurationSeconds)
1007 }
1008
1009 if v.Policy != nil {
1010 objectKey := object.Key("Policy")
1011 objectKey.String(*v.Policy)
1012 }
1013
1014 if v.PolicyArns != nil {
1015 objectKey := object.Key("PolicyArns")
1016 if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
1017 return err
1018 }
1019 }
1020
1021 if v.ProviderId != nil {
1022 objectKey := object.Key("ProviderId")
1023 objectKey.String(*v.ProviderId)
1024 }
1025
1026 if v.RoleArn != nil {
1027 objectKey := object.Key("RoleArn")
1028 objectKey.String(*v.RoleArn)
1029 }
1030
1031 if v.RoleSessionName != nil {
1032 objectKey := object.Key("RoleSessionName")
1033 objectKey.String(*v.RoleSessionName)
1034 }
1035
1036 if v.WebIdentityToken != nil {
1037 objectKey := object.Key("WebIdentityToken")
1038 objectKey.String(*v.WebIdentityToken)
1039 }
1040
1041 return nil
1042 }
1043
1044 func awsAwsquery_serializeOpDocumentAssumeRootInput(v *AssumeRootInput, value query.Value) error {
1045 object := value.Object()
1046 _ = object
1047
1048 if v.DurationSeconds != nil {
1049 objectKey := object.Key("DurationSeconds")
1050 objectKey.Integer(*v.DurationSeconds)
1051 }
1052
1053 if v.TargetPrincipal != nil {
1054 objectKey := object.Key("TargetPrincipal")
1055 objectKey.String(*v.TargetPrincipal)
1056 }
1057
1058 if v.TaskPolicyArn != nil {
1059 objectKey := object.Key("TaskPolicyArn")
1060 if err := awsAwsquery_serializeDocumentPolicyDescriptorType(v.TaskPolicyArn, objectKey); err != nil {
1061 return err
1062 }
1063 }
1064
1065 return nil
1066 }
1067
1068 func awsAwsquery_serializeOpDocumentDecodeAuthorizationMessageInput(v *DecodeAuthorizationMessageInput, value query.Value) error {
1069 object := value.Object()
1070 _ = object
1071
1072 if v.EncodedMessage != nil {
1073 objectKey := object.Key("EncodedMessage")
1074 objectKey.String(*v.EncodedMessage)
1075 }
1076
1077 return nil
1078 }
1079
1080 func awsAwsquery_serializeOpDocumentGetAccessKeyInfoInput(v *GetAccessKeyInfoInput, value query.Value) error {
1081 object := value.Object()
1082 _ = object
1083
1084 if v.AccessKeyId != nil {
1085 objectKey := object.Key("AccessKeyId")
1086 objectKey.String(*v.AccessKeyId)
1087 }
1088
1089 return nil
1090 }
1091
1092 func awsAwsquery_serializeOpDocumentGetCallerIdentityInput(v *GetCallerIdentityInput, value query.Value) error {
1093 object := value.Object()
1094 _ = object
1095
1096 return nil
1097 }
1098
1099 func awsAwsquery_serializeOpDocumentGetDelegatedAccessTokenInput(v *GetDelegatedAccessTokenInput, value query.Value) error {
1100 object := value.Object()
1101 _ = object
1102
1103 if v.TradeInToken != nil {
1104 objectKey := object.Key("TradeInToken")
1105 objectKey.String(*v.TradeInToken)
1106 }
1107
1108 return nil
1109 }
1110
1111 func awsAwsquery_serializeOpDocumentGetFederationTokenInput(v *GetFederationTokenInput, value query.Value) error {
1112 object := value.Object()
1113 _ = object
1114
1115 if v.DurationSeconds != nil {
1116 objectKey := object.Key("DurationSeconds")
1117 objectKey.Integer(*v.DurationSeconds)
1118 }
1119
1120 if v.Name != nil {
1121 objectKey := object.Key("Name")
1122 objectKey.String(*v.Name)
1123 }
1124
1125 if v.Policy != nil {
1126 objectKey := object.Key("Policy")
1127 objectKey.String(*v.Policy)
1128 }
1129
1130 if v.PolicyArns != nil {
1131 objectKey := object.Key("PolicyArns")
1132 if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
1133 return err
1134 }
1135 }
1136
1137 if v.Tags != nil {
1138 objectKey := object.Key("Tags")
1139 if err := awsAwsquery_serializeDocumentTagListType(v.Tags, objectKey); err != nil {
1140 return err
1141 }
1142 }
1143
1144 return nil
1145 }
1146
1147 func awsAwsquery_serializeOpDocumentGetSessionTokenInput(v *GetSessionTokenInput, value query.Value) error {
1148 object := value.Object()
1149 _ = object
1150
1151 if v.DurationSeconds != nil {
1152 objectKey := object.Key("DurationSeconds")
1153 objectKey.Integer(*v.DurationSeconds)
1154 }
1155
1156 if v.SerialNumber != nil {
1157 objectKey := object.Key("SerialNumber")
1158 objectKey.String(*v.SerialNumber)
1159 }
1160
1161 if v.TokenCode != nil {
1162 objectKey := object.Key("TokenCode")
1163 objectKey.String(*v.TokenCode)
1164 }
1165
1166 return nil
1167 }
1168
1169 func awsAwsquery_serializeOpDocumentGetWebIdentityTokenInput(v *GetWebIdentityTokenInput, value query.Value) error {
1170 object := value.Object()
1171 _ = object
1172
1173 if v.Audience != nil {
1174 objectKey := object.Key("Audience")
1175 if err := awsAwsquery_serializeDocumentWebIdentityTokenAudienceListType(v.Audience, objectKey); err != nil {
1176 return err
1177 }
1178 }
1179
1180 if v.DurationSeconds != nil {
1181 objectKey := object.Key("DurationSeconds")
1182 objectKey.Integer(*v.DurationSeconds)
1183 }
1184
1185 if v.SigningAlgorithm != nil {
1186 objectKey := object.Key("SigningAlgorithm")
1187 objectKey.String(*v.SigningAlgorithm)
1188 }
1189
1190 if v.Tags != nil {
1191 objectKey := object.Key("Tags")
1192 if err := awsAwsquery_serializeDocumentTagListType(v.Tags, objectKey); err != nil {
1193 return err
1194 }
1195 }
1196
1197 return nil
1198 }
1199