src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

serializers.go (36688B)

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