src

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

serializers.go (30505B)

      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_serializeOpGetFederationToken struct {
    506 }
    507 
    508 func (*awsAwsquery_serializeOpGetFederationToken) ID() string {
    509 	return "OperationSerializer"
    510 }
    511 
    512 func (m *awsAwsquery_serializeOpGetFederationToken) 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.(*GetFederationTokenInput)
    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("GetFederationToken")
    550 	body.Key("Version").String("2011-06-15")
    551 
    552 	if err := awsAwsquery_serializeOpDocumentGetFederationTokenInput(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_serializeOpGetSessionToken struct {
    576 }
    577 
    578 func (*awsAwsquery_serializeOpGetSessionToken) ID() string {
    579 	return "OperationSerializer"
    580 }
    581 
    582 func (m *awsAwsquery_serializeOpGetSessionToken) 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.(*GetSessionTokenInput)
    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("GetSessionToken")
    620 	body.Key("Version").String("2011-06-15")
    621 
    622 	if err := awsAwsquery_serializeOpDocumentGetSessionTokenInput(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 func awsAwsquery_serializeDocumentPolicyDescriptorListType(v []types.PolicyDescriptorType, value query.Value) error {
    645 	array := value.Array("member")
    646 
    647 	for i := range v {
    648 		av := array.Value()
    649 		if err := awsAwsquery_serializeDocumentPolicyDescriptorType(&v[i], av); err != nil {
    650 			return err
    651 		}
    652 	}
    653 	return nil
    654 }
    655 
    656 func awsAwsquery_serializeDocumentPolicyDescriptorType(v *types.PolicyDescriptorType, value query.Value) error {
    657 	object := value.Object()
    658 	_ = object
    659 
    660 	if v.Arn != nil {
    661 		objectKey := object.Key("arn")
    662 		objectKey.String(*v.Arn)
    663 	}
    664 
    665 	return nil
    666 }
    667 
    668 func awsAwsquery_serializeDocumentProvidedContext(v *types.ProvidedContext, value query.Value) error {
    669 	object := value.Object()
    670 	_ = object
    671 
    672 	if v.ContextAssertion != nil {
    673 		objectKey := object.Key("ContextAssertion")
    674 		objectKey.String(*v.ContextAssertion)
    675 	}
    676 
    677 	if v.ProviderArn != nil {
    678 		objectKey := object.Key("ProviderArn")
    679 		objectKey.String(*v.ProviderArn)
    680 	}
    681 
    682 	return nil
    683 }
    684 
    685 func awsAwsquery_serializeDocumentProvidedContextsListType(v []types.ProvidedContext, value query.Value) error {
    686 	array := value.Array("member")
    687 
    688 	for i := range v {
    689 		av := array.Value()
    690 		if err := awsAwsquery_serializeDocumentProvidedContext(&v[i], av); err != nil {
    691 			return err
    692 		}
    693 	}
    694 	return nil
    695 }
    696 
    697 func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error {
    698 	object := value.Object()
    699 	_ = object
    700 
    701 	if v.Key != nil {
    702 		objectKey := object.Key("Key")
    703 		objectKey.String(*v.Key)
    704 	}
    705 
    706 	if v.Value != nil {
    707 		objectKey := object.Key("Value")
    708 		objectKey.String(*v.Value)
    709 	}
    710 
    711 	return nil
    712 }
    713 
    714 func awsAwsquery_serializeDocumentTagKeyListType(v []string, value query.Value) error {
    715 	array := value.Array("member")
    716 
    717 	for i := range v {
    718 		av := array.Value()
    719 		av.String(v[i])
    720 	}
    721 	return nil
    722 }
    723 
    724 func awsAwsquery_serializeDocumentTagListType(v []types.Tag, value query.Value) error {
    725 	array := value.Array("member")
    726 
    727 	for i := range v {
    728 		av := array.Value()
    729 		if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil {
    730 			return err
    731 		}
    732 	}
    733 	return nil
    734 }
    735 
    736 func awsAwsquery_serializeOpDocumentAssumeRoleInput(v *AssumeRoleInput, value query.Value) error {
    737 	object := value.Object()
    738 	_ = object
    739 
    740 	if v.DurationSeconds != nil {
    741 		objectKey := object.Key("DurationSeconds")
    742 		objectKey.Integer(*v.DurationSeconds)
    743 	}
    744 
    745 	if v.ExternalId != nil {
    746 		objectKey := object.Key("ExternalId")
    747 		objectKey.String(*v.ExternalId)
    748 	}
    749 
    750 	if v.Policy != nil {
    751 		objectKey := object.Key("Policy")
    752 		objectKey.String(*v.Policy)
    753 	}
    754 
    755 	if v.PolicyArns != nil {
    756 		objectKey := object.Key("PolicyArns")
    757 		if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
    758 			return err
    759 		}
    760 	}
    761 
    762 	if v.ProvidedContexts != nil {
    763 		objectKey := object.Key("ProvidedContexts")
    764 		if err := awsAwsquery_serializeDocumentProvidedContextsListType(v.ProvidedContexts, objectKey); err != nil {
    765 			return err
    766 		}
    767 	}
    768 
    769 	if v.RoleArn != nil {
    770 		objectKey := object.Key("RoleArn")
    771 		objectKey.String(*v.RoleArn)
    772 	}
    773 
    774 	if v.RoleSessionName != nil {
    775 		objectKey := object.Key("RoleSessionName")
    776 		objectKey.String(*v.RoleSessionName)
    777 	}
    778 
    779 	if v.SerialNumber != nil {
    780 		objectKey := object.Key("SerialNumber")
    781 		objectKey.String(*v.SerialNumber)
    782 	}
    783 
    784 	if v.SourceIdentity != nil {
    785 		objectKey := object.Key("SourceIdentity")
    786 		objectKey.String(*v.SourceIdentity)
    787 	}
    788 
    789 	if v.Tags != nil {
    790 		objectKey := object.Key("Tags")
    791 		if err := awsAwsquery_serializeDocumentTagListType(v.Tags, objectKey); err != nil {
    792 			return err
    793 		}
    794 	}
    795 
    796 	if v.TokenCode != nil {
    797 		objectKey := object.Key("TokenCode")
    798 		objectKey.String(*v.TokenCode)
    799 	}
    800 
    801 	if v.TransitiveTagKeys != nil {
    802 		objectKey := object.Key("TransitiveTagKeys")
    803 		if err := awsAwsquery_serializeDocumentTagKeyListType(v.TransitiveTagKeys, objectKey); err != nil {
    804 			return err
    805 		}
    806 	}
    807 
    808 	return nil
    809 }
    810 
    811 func awsAwsquery_serializeOpDocumentAssumeRoleWithSAMLInput(v *AssumeRoleWithSAMLInput, value query.Value) error {
    812 	object := value.Object()
    813 	_ = object
    814 
    815 	if v.DurationSeconds != nil {
    816 		objectKey := object.Key("DurationSeconds")
    817 		objectKey.Integer(*v.DurationSeconds)
    818 	}
    819 
    820 	if v.Policy != nil {
    821 		objectKey := object.Key("Policy")
    822 		objectKey.String(*v.Policy)
    823 	}
    824 
    825 	if v.PolicyArns != nil {
    826 		objectKey := object.Key("PolicyArns")
    827 		if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
    828 			return err
    829 		}
    830 	}
    831 
    832 	if v.PrincipalArn != nil {
    833 		objectKey := object.Key("PrincipalArn")
    834 		objectKey.String(*v.PrincipalArn)
    835 	}
    836 
    837 	if v.RoleArn != nil {
    838 		objectKey := object.Key("RoleArn")
    839 		objectKey.String(*v.RoleArn)
    840 	}
    841 
    842 	if v.SAMLAssertion != nil {
    843 		objectKey := object.Key("SAMLAssertion")
    844 		objectKey.String(*v.SAMLAssertion)
    845 	}
    846 
    847 	return nil
    848 }
    849 
    850 func awsAwsquery_serializeOpDocumentAssumeRoleWithWebIdentityInput(v *AssumeRoleWithWebIdentityInput, value query.Value) error {
    851 	object := value.Object()
    852 	_ = object
    853 
    854 	if v.DurationSeconds != nil {
    855 		objectKey := object.Key("DurationSeconds")
    856 		objectKey.Integer(*v.DurationSeconds)
    857 	}
    858 
    859 	if v.Policy != nil {
    860 		objectKey := object.Key("Policy")
    861 		objectKey.String(*v.Policy)
    862 	}
    863 
    864 	if v.PolicyArns != nil {
    865 		objectKey := object.Key("PolicyArns")
    866 		if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
    867 			return err
    868 		}
    869 	}
    870 
    871 	if v.ProviderId != nil {
    872 		objectKey := object.Key("ProviderId")
    873 		objectKey.String(*v.ProviderId)
    874 	}
    875 
    876 	if v.RoleArn != nil {
    877 		objectKey := object.Key("RoleArn")
    878 		objectKey.String(*v.RoleArn)
    879 	}
    880 
    881 	if v.RoleSessionName != nil {
    882 		objectKey := object.Key("RoleSessionName")
    883 		objectKey.String(*v.RoleSessionName)
    884 	}
    885 
    886 	if v.WebIdentityToken != nil {
    887 		objectKey := object.Key("WebIdentityToken")
    888 		objectKey.String(*v.WebIdentityToken)
    889 	}
    890 
    891 	return nil
    892 }
    893 
    894 func awsAwsquery_serializeOpDocumentAssumeRootInput(v *AssumeRootInput, value query.Value) error {
    895 	object := value.Object()
    896 	_ = object
    897 
    898 	if v.DurationSeconds != nil {
    899 		objectKey := object.Key("DurationSeconds")
    900 		objectKey.Integer(*v.DurationSeconds)
    901 	}
    902 
    903 	if v.TargetPrincipal != nil {
    904 		objectKey := object.Key("TargetPrincipal")
    905 		objectKey.String(*v.TargetPrincipal)
    906 	}
    907 
    908 	if v.TaskPolicyArn != nil {
    909 		objectKey := object.Key("TaskPolicyArn")
    910 		if err := awsAwsquery_serializeDocumentPolicyDescriptorType(v.TaskPolicyArn, objectKey); err != nil {
    911 			return err
    912 		}
    913 	}
    914 
    915 	return nil
    916 }
    917 
    918 func awsAwsquery_serializeOpDocumentDecodeAuthorizationMessageInput(v *DecodeAuthorizationMessageInput, value query.Value) error {
    919 	object := value.Object()
    920 	_ = object
    921 
    922 	if v.EncodedMessage != nil {
    923 		objectKey := object.Key("EncodedMessage")
    924 		objectKey.String(*v.EncodedMessage)
    925 	}
    926 
    927 	return nil
    928 }
    929 
    930 func awsAwsquery_serializeOpDocumentGetAccessKeyInfoInput(v *GetAccessKeyInfoInput, value query.Value) error {
    931 	object := value.Object()
    932 	_ = object
    933 
    934 	if v.AccessKeyId != nil {
    935 		objectKey := object.Key("AccessKeyId")
    936 		objectKey.String(*v.AccessKeyId)
    937 	}
    938 
    939 	return nil
    940 }
    941 
    942 func awsAwsquery_serializeOpDocumentGetCallerIdentityInput(v *GetCallerIdentityInput, value query.Value) error {
    943 	object := value.Object()
    944 	_ = object
    945 
    946 	return nil
    947 }
    948 
    949 func awsAwsquery_serializeOpDocumentGetFederationTokenInput(v *GetFederationTokenInput, value query.Value) error {
    950 	object := value.Object()
    951 	_ = object
    952 
    953 	if v.DurationSeconds != nil {
    954 		objectKey := object.Key("DurationSeconds")
    955 		objectKey.Integer(*v.DurationSeconds)
    956 	}
    957 
    958 	if v.Name != nil {
    959 		objectKey := object.Key("Name")
    960 		objectKey.String(*v.Name)
    961 	}
    962 
    963 	if v.Policy != nil {
    964 		objectKey := object.Key("Policy")
    965 		objectKey.String(*v.Policy)
    966 	}
    967 
    968 	if v.PolicyArns != nil {
    969 		objectKey := object.Key("PolicyArns")
    970 		if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
    971 			return err
    972 		}
    973 	}
    974 
    975 	if v.Tags != nil {
    976 		objectKey := object.Key("Tags")
    977 		if err := awsAwsquery_serializeDocumentTagListType(v.Tags, objectKey); err != nil {
    978 			return err
    979 		}
    980 	}
    981 
    982 	return nil
    983 }
    984 
    985 func awsAwsquery_serializeOpDocumentGetSessionTokenInput(v *GetSessionTokenInput, value query.Value) error {
    986 	object := value.Object()
    987 	_ = object
    988 
    989 	if v.DurationSeconds != nil {
    990 		objectKey := object.Key("DurationSeconds")
    991 		objectKey.Integer(*v.DurationSeconds)
    992 	}
    993 
    994 	if v.SerialNumber != nil {
    995 		objectKey := object.Key("SerialNumber")
    996 		objectKey.String(*v.SerialNumber)
    997 	}
    998 
    999 	if v.TokenCode != nil {
   1000 		objectKey := object.Key("TokenCode")
   1001 		objectKey.String(*v.TokenCode)
   1002 	}
   1003 
   1004 	return nil
   1005 }