code.dwrz.net

Go monorepo.
Log | Files | Refs

serializers.go (25163B)

      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 	smithyhttp "github.com/aws/smithy-go/transport/http"
     15 	"path"
     16 )
     17 
     18 type awsAwsquery_serializeOpAssumeRole struct {
     19 }
     20 
     21 func (*awsAwsquery_serializeOpAssumeRole) ID() string {
     22 	return "OperationSerializer"
     23 }
     24 
     25 func (m *awsAwsquery_serializeOpAssumeRole) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
     26 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
     27 ) {
     28 	request, ok := in.Request.(*smithyhttp.Request)
     29 	if !ok {
     30 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
     31 	}
     32 
     33 	input, ok := in.Parameters.(*AssumeRoleInput)
     34 	_ = input
     35 	if !ok {
     36 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
     37 	}
     38 
     39 	operationPath := "/"
     40 	if len(request.Request.URL.Path) == 0 {
     41 		request.Request.URL.Path = operationPath
     42 	} else {
     43 		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
     44 		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
     45 			request.Request.URL.Path += "/"
     46 		}
     47 	}
     48 	request.Request.Method = "POST"
     49 	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
     50 	if err != nil {
     51 		return out, metadata, &smithy.SerializationError{Err: err}
     52 	}
     53 	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
     54 
     55 	bodyWriter := bytes.NewBuffer(nil)
     56 	bodyEncoder := query.NewEncoder(bodyWriter)
     57 	body := bodyEncoder.Object()
     58 	body.Key("Action").String("AssumeRole")
     59 	body.Key("Version").String("2011-06-15")
     60 
     61 	if err := awsAwsquery_serializeOpDocumentAssumeRoleInput(input, bodyEncoder.Value); err != nil {
     62 		return out, metadata, &smithy.SerializationError{Err: err}
     63 	}
     64 
     65 	err = bodyEncoder.Encode()
     66 	if err != nil {
     67 		return out, metadata, &smithy.SerializationError{Err: err}
     68 	}
     69 
     70 	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
     71 		return out, metadata, &smithy.SerializationError{Err: err}
     72 	}
     73 
     74 	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
     75 		return out, metadata, &smithy.SerializationError{Err: err}
     76 	}
     77 	in.Request = request
     78 
     79 	return next.HandleSerialize(ctx, in)
     80 }
     81 
     82 type awsAwsquery_serializeOpAssumeRoleWithSAML struct {
     83 }
     84 
     85 func (*awsAwsquery_serializeOpAssumeRoleWithSAML) ID() string {
     86 	return "OperationSerializer"
     87 }
     88 
     89 func (m *awsAwsquery_serializeOpAssumeRoleWithSAML) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
     90 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
     91 ) {
     92 	request, ok := in.Request.(*smithyhttp.Request)
     93 	if !ok {
     94 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
     95 	}
     96 
     97 	input, ok := in.Parameters.(*AssumeRoleWithSAMLInput)
     98 	_ = input
     99 	if !ok {
    100 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    101 	}
    102 
    103 	operationPath := "/"
    104 	if len(request.Request.URL.Path) == 0 {
    105 		request.Request.URL.Path = operationPath
    106 	} else {
    107 		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
    108 		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
    109 			request.Request.URL.Path += "/"
    110 		}
    111 	}
    112 	request.Request.Method = "POST"
    113 	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    114 	if err != nil {
    115 		return out, metadata, &smithy.SerializationError{Err: err}
    116 	}
    117 	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
    118 
    119 	bodyWriter := bytes.NewBuffer(nil)
    120 	bodyEncoder := query.NewEncoder(bodyWriter)
    121 	body := bodyEncoder.Object()
    122 	body.Key("Action").String("AssumeRoleWithSAML")
    123 	body.Key("Version").String("2011-06-15")
    124 
    125 	if err := awsAwsquery_serializeOpDocumentAssumeRoleWithSAMLInput(input, bodyEncoder.Value); err != nil {
    126 		return out, metadata, &smithy.SerializationError{Err: err}
    127 	}
    128 
    129 	err = bodyEncoder.Encode()
    130 	if err != nil {
    131 		return out, metadata, &smithy.SerializationError{Err: err}
    132 	}
    133 
    134 	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
    135 		return out, metadata, &smithy.SerializationError{Err: err}
    136 	}
    137 
    138 	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
    139 		return out, metadata, &smithy.SerializationError{Err: err}
    140 	}
    141 	in.Request = request
    142 
    143 	return next.HandleSerialize(ctx, in)
    144 }
    145 
    146 type awsAwsquery_serializeOpAssumeRoleWithWebIdentity struct {
    147 }
    148 
    149 func (*awsAwsquery_serializeOpAssumeRoleWithWebIdentity) ID() string {
    150 	return "OperationSerializer"
    151 }
    152 
    153 func (m *awsAwsquery_serializeOpAssumeRoleWithWebIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    154 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    155 ) {
    156 	request, ok := in.Request.(*smithyhttp.Request)
    157 	if !ok {
    158 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    159 	}
    160 
    161 	input, ok := in.Parameters.(*AssumeRoleWithWebIdentityInput)
    162 	_ = input
    163 	if !ok {
    164 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    165 	}
    166 
    167 	operationPath := "/"
    168 	if len(request.Request.URL.Path) == 0 {
    169 		request.Request.URL.Path = operationPath
    170 	} else {
    171 		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
    172 		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
    173 			request.Request.URL.Path += "/"
    174 		}
    175 	}
    176 	request.Request.Method = "POST"
    177 	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    178 	if err != nil {
    179 		return out, metadata, &smithy.SerializationError{Err: err}
    180 	}
    181 	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
    182 
    183 	bodyWriter := bytes.NewBuffer(nil)
    184 	bodyEncoder := query.NewEncoder(bodyWriter)
    185 	body := bodyEncoder.Object()
    186 	body.Key("Action").String("AssumeRoleWithWebIdentity")
    187 	body.Key("Version").String("2011-06-15")
    188 
    189 	if err := awsAwsquery_serializeOpDocumentAssumeRoleWithWebIdentityInput(input, bodyEncoder.Value); err != nil {
    190 		return out, metadata, &smithy.SerializationError{Err: err}
    191 	}
    192 
    193 	err = bodyEncoder.Encode()
    194 	if err != nil {
    195 		return out, metadata, &smithy.SerializationError{Err: err}
    196 	}
    197 
    198 	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
    199 		return out, metadata, &smithy.SerializationError{Err: err}
    200 	}
    201 
    202 	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
    203 		return out, metadata, &smithy.SerializationError{Err: err}
    204 	}
    205 	in.Request = request
    206 
    207 	return next.HandleSerialize(ctx, in)
    208 }
    209 
    210 type awsAwsquery_serializeOpDecodeAuthorizationMessage struct {
    211 }
    212 
    213 func (*awsAwsquery_serializeOpDecodeAuthorizationMessage) ID() string {
    214 	return "OperationSerializer"
    215 }
    216 
    217 func (m *awsAwsquery_serializeOpDecodeAuthorizationMessage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    218 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    219 ) {
    220 	request, ok := in.Request.(*smithyhttp.Request)
    221 	if !ok {
    222 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    223 	}
    224 
    225 	input, ok := in.Parameters.(*DecodeAuthorizationMessageInput)
    226 	_ = input
    227 	if !ok {
    228 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    229 	}
    230 
    231 	operationPath := "/"
    232 	if len(request.Request.URL.Path) == 0 {
    233 		request.Request.URL.Path = operationPath
    234 	} else {
    235 		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
    236 		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
    237 			request.Request.URL.Path += "/"
    238 		}
    239 	}
    240 	request.Request.Method = "POST"
    241 	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    242 	if err != nil {
    243 		return out, metadata, &smithy.SerializationError{Err: err}
    244 	}
    245 	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
    246 
    247 	bodyWriter := bytes.NewBuffer(nil)
    248 	bodyEncoder := query.NewEncoder(bodyWriter)
    249 	body := bodyEncoder.Object()
    250 	body.Key("Action").String("DecodeAuthorizationMessage")
    251 	body.Key("Version").String("2011-06-15")
    252 
    253 	if err := awsAwsquery_serializeOpDocumentDecodeAuthorizationMessageInput(input, bodyEncoder.Value); err != nil {
    254 		return out, metadata, &smithy.SerializationError{Err: err}
    255 	}
    256 
    257 	err = bodyEncoder.Encode()
    258 	if err != nil {
    259 		return out, metadata, &smithy.SerializationError{Err: err}
    260 	}
    261 
    262 	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
    263 		return out, metadata, &smithy.SerializationError{Err: err}
    264 	}
    265 
    266 	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
    267 		return out, metadata, &smithy.SerializationError{Err: err}
    268 	}
    269 	in.Request = request
    270 
    271 	return next.HandleSerialize(ctx, in)
    272 }
    273 
    274 type awsAwsquery_serializeOpGetAccessKeyInfo struct {
    275 }
    276 
    277 func (*awsAwsquery_serializeOpGetAccessKeyInfo) ID() string {
    278 	return "OperationSerializer"
    279 }
    280 
    281 func (m *awsAwsquery_serializeOpGetAccessKeyInfo) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    282 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    283 ) {
    284 	request, ok := in.Request.(*smithyhttp.Request)
    285 	if !ok {
    286 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    287 	}
    288 
    289 	input, ok := in.Parameters.(*GetAccessKeyInfoInput)
    290 	_ = input
    291 	if !ok {
    292 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    293 	}
    294 
    295 	operationPath := "/"
    296 	if len(request.Request.URL.Path) == 0 {
    297 		request.Request.URL.Path = operationPath
    298 	} else {
    299 		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
    300 		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
    301 			request.Request.URL.Path += "/"
    302 		}
    303 	}
    304 	request.Request.Method = "POST"
    305 	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    306 	if err != nil {
    307 		return out, metadata, &smithy.SerializationError{Err: err}
    308 	}
    309 	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
    310 
    311 	bodyWriter := bytes.NewBuffer(nil)
    312 	bodyEncoder := query.NewEncoder(bodyWriter)
    313 	body := bodyEncoder.Object()
    314 	body.Key("Action").String("GetAccessKeyInfo")
    315 	body.Key("Version").String("2011-06-15")
    316 
    317 	if err := awsAwsquery_serializeOpDocumentGetAccessKeyInfoInput(input, bodyEncoder.Value); err != nil {
    318 		return out, metadata, &smithy.SerializationError{Err: err}
    319 	}
    320 
    321 	err = bodyEncoder.Encode()
    322 	if err != nil {
    323 		return out, metadata, &smithy.SerializationError{Err: err}
    324 	}
    325 
    326 	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
    327 		return out, metadata, &smithy.SerializationError{Err: err}
    328 	}
    329 
    330 	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
    331 		return out, metadata, &smithy.SerializationError{Err: err}
    332 	}
    333 	in.Request = request
    334 
    335 	return next.HandleSerialize(ctx, in)
    336 }
    337 
    338 type awsAwsquery_serializeOpGetCallerIdentity struct {
    339 }
    340 
    341 func (*awsAwsquery_serializeOpGetCallerIdentity) ID() string {
    342 	return "OperationSerializer"
    343 }
    344 
    345 func (m *awsAwsquery_serializeOpGetCallerIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    346 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    347 ) {
    348 	request, ok := in.Request.(*smithyhttp.Request)
    349 	if !ok {
    350 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    351 	}
    352 
    353 	input, ok := in.Parameters.(*GetCallerIdentityInput)
    354 	_ = input
    355 	if !ok {
    356 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    357 	}
    358 
    359 	operationPath := "/"
    360 	if len(request.Request.URL.Path) == 0 {
    361 		request.Request.URL.Path = operationPath
    362 	} else {
    363 		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
    364 		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
    365 			request.Request.URL.Path += "/"
    366 		}
    367 	}
    368 	request.Request.Method = "POST"
    369 	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    370 	if err != nil {
    371 		return out, metadata, &smithy.SerializationError{Err: err}
    372 	}
    373 	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
    374 
    375 	bodyWriter := bytes.NewBuffer(nil)
    376 	bodyEncoder := query.NewEncoder(bodyWriter)
    377 	body := bodyEncoder.Object()
    378 	body.Key("Action").String("GetCallerIdentity")
    379 	body.Key("Version").String("2011-06-15")
    380 
    381 	err = bodyEncoder.Encode()
    382 	if err != nil {
    383 		return out, metadata, &smithy.SerializationError{Err: err}
    384 	}
    385 
    386 	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
    387 		return out, metadata, &smithy.SerializationError{Err: err}
    388 	}
    389 
    390 	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
    391 		return out, metadata, &smithy.SerializationError{Err: err}
    392 	}
    393 	in.Request = request
    394 
    395 	return next.HandleSerialize(ctx, in)
    396 }
    397 
    398 type awsAwsquery_serializeOpGetFederationToken struct {
    399 }
    400 
    401 func (*awsAwsquery_serializeOpGetFederationToken) ID() string {
    402 	return "OperationSerializer"
    403 }
    404 
    405 func (m *awsAwsquery_serializeOpGetFederationToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    406 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    407 ) {
    408 	request, ok := in.Request.(*smithyhttp.Request)
    409 	if !ok {
    410 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    411 	}
    412 
    413 	input, ok := in.Parameters.(*GetFederationTokenInput)
    414 	_ = input
    415 	if !ok {
    416 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    417 	}
    418 
    419 	operationPath := "/"
    420 	if len(request.Request.URL.Path) == 0 {
    421 		request.Request.URL.Path = operationPath
    422 	} else {
    423 		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
    424 		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
    425 			request.Request.URL.Path += "/"
    426 		}
    427 	}
    428 	request.Request.Method = "POST"
    429 	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    430 	if err != nil {
    431 		return out, metadata, &smithy.SerializationError{Err: err}
    432 	}
    433 	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
    434 
    435 	bodyWriter := bytes.NewBuffer(nil)
    436 	bodyEncoder := query.NewEncoder(bodyWriter)
    437 	body := bodyEncoder.Object()
    438 	body.Key("Action").String("GetFederationToken")
    439 	body.Key("Version").String("2011-06-15")
    440 
    441 	if err := awsAwsquery_serializeOpDocumentGetFederationTokenInput(input, bodyEncoder.Value); err != nil {
    442 		return out, metadata, &smithy.SerializationError{Err: err}
    443 	}
    444 
    445 	err = bodyEncoder.Encode()
    446 	if err != nil {
    447 		return out, metadata, &smithy.SerializationError{Err: err}
    448 	}
    449 
    450 	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
    451 		return out, metadata, &smithy.SerializationError{Err: err}
    452 	}
    453 
    454 	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
    455 		return out, metadata, &smithy.SerializationError{Err: err}
    456 	}
    457 	in.Request = request
    458 
    459 	return next.HandleSerialize(ctx, in)
    460 }
    461 
    462 type awsAwsquery_serializeOpGetSessionToken struct {
    463 }
    464 
    465 func (*awsAwsquery_serializeOpGetSessionToken) ID() string {
    466 	return "OperationSerializer"
    467 }
    468 
    469 func (m *awsAwsquery_serializeOpGetSessionToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    470 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    471 ) {
    472 	request, ok := in.Request.(*smithyhttp.Request)
    473 	if !ok {
    474 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    475 	}
    476 
    477 	input, ok := in.Parameters.(*GetSessionTokenInput)
    478 	_ = input
    479 	if !ok {
    480 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    481 	}
    482 
    483 	operationPath := "/"
    484 	if len(request.Request.URL.Path) == 0 {
    485 		request.Request.URL.Path = operationPath
    486 	} else {
    487 		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
    488 		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
    489 			request.Request.URL.Path += "/"
    490 		}
    491 	}
    492 	request.Request.Method = "POST"
    493 	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    494 	if err != nil {
    495 		return out, metadata, &smithy.SerializationError{Err: err}
    496 	}
    497 	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
    498 
    499 	bodyWriter := bytes.NewBuffer(nil)
    500 	bodyEncoder := query.NewEncoder(bodyWriter)
    501 	body := bodyEncoder.Object()
    502 	body.Key("Action").String("GetSessionToken")
    503 	body.Key("Version").String("2011-06-15")
    504 
    505 	if err := awsAwsquery_serializeOpDocumentGetSessionTokenInput(input, bodyEncoder.Value); err != nil {
    506 		return out, metadata, &smithy.SerializationError{Err: err}
    507 	}
    508 
    509 	err = bodyEncoder.Encode()
    510 	if err != nil {
    511 		return out, metadata, &smithy.SerializationError{Err: err}
    512 	}
    513 
    514 	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
    515 		return out, metadata, &smithy.SerializationError{Err: err}
    516 	}
    517 
    518 	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
    519 		return out, metadata, &smithy.SerializationError{Err: err}
    520 	}
    521 	in.Request = request
    522 
    523 	return next.HandleSerialize(ctx, in)
    524 }
    525 func awsAwsquery_serializeDocumentPolicyDescriptorListType(v []types.PolicyDescriptorType, value query.Value) error {
    526 	if len(v) == 0 {
    527 		return nil
    528 	}
    529 	array := value.Array("member")
    530 
    531 	for i := range v {
    532 		av := array.Value()
    533 		if err := awsAwsquery_serializeDocumentPolicyDescriptorType(&v[i], av); err != nil {
    534 			return err
    535 		}
    536 	}
    537 	return nil
    538 }
    539 
    540 func awsAwsquery_serializeDocumentPolicyDescriptorType(v *types.PolicyDescriptorType, value query.Value) error {
    541 	object := value.Object()
    542 	_ = object
    543 
    544 	if v.Arn != nil {
    545 		objectKey := object.Key("arn")
    546 		objectKey.String(*v.Arn)
    547 	}
    548 
    549 	return nil
    550 }
    551 
    552 func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error {
    553 	object := value.Object()
    554 	_ = object
    555 
    556 	if v.Key != nil {
    557 		objectKey := object.Key("Key")
    558 		objectKey.String(*v.Key)
    559 	}
    560 
    561 	if v.Value != nil {
    562 		objectKey := object.Key("Value")
    563 		objectKey.String(*v.Value)
    564 	}
    565 
    566 	return nil
    567 }
    568 
    569 func awsAwsquery_serializeDocumentTagKeyListType(v []string, value query.Value) error {
    570 	if len(v) == 0 {
    571 		return nil
    572 	}
    573 	array := value.Array("member")
    574 
    575 	for i := range v {
    576 		av := array.Value()
    577 		av.String(v[i])
    578 	}
    579 	return nil
    580 }
    581 
    582 func awsAwsquery_serializeDocumentTagListType(v []types.Tag, value query.Value) error {
    583 	if len(v) == 0 {
    584 		return nil
    585 	}
    586 	array := value.Array("member")
    587 
    588 	for i := range v {
    589 		av := array.Value()
    590 		if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil {
    591 			return err
    592 		}
    593 	}
    594 	return nil
    595 }
    596 
    597 func awsAwsquery_serializeOpDocumentAssumeRoleInput(v *AssumeRoleInput, value query.Value) error {
    598 	object := value.Object()
    599 	_ = object
    600 
    601 	if v.DurationSeconds != nil {
    602 		objectKey := object.Key("DurationSeconds")
    603 		objectKey.Integer(*v.DurationSeconds)
    604 	}
    605 
    606 	if v.ExternalId != nil {
    607 		objectKey := object.Key("ExternalId")
    608 		objectKey.String(*v.ExternalId)
    609 	}
    610 
    611 	if v.Policy != nil {
    612 		objectKey := object.Key("Policy")
    613 		objectKey.String(*v.Policy)
    614 	}
    615 
    616 	if v.PolicyArns != nil {
    617 		objectKey := object.Key("PolicyArns")
    618 		if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
    619 			return err
    620 		}
    621 	}
    622 
    623 	if v.RoleArn != nil {
    624 		objectKey := object.Key("RoleArn")
    625 		objectKey.String(*v.RoleArn)
    626 	}
    627 
    628 	if v.RoleSessionName != nil {
    629 		objectKey := object.Key("RoleSessionName")
    630 		objectKey.String(*v.RoleSessionName)
    631 	}
    632 
    633 	if v.SerialNumber != nil {
    634 		objectKey := object.Key("SerialNumber")
    635 		objectKey.String(*v.SerialNumber)
    636 	}
    637 
    638 	if v.SourceIdentity != nil {
    639 		objectKey := object.Key("SourceIdentity")
    640 		objectKey.String(*v.SourceIdentity)
    641 	}
    642 
    643 	if v.Tags != nil {
    644 		objectKey := object.Key("Tags")
    645 		if err := awsAwsquery_serializeDocumentTagListType(v.Tags, objectKey); err != nil {
    646 			return err
    647 		}
    648 	}
    649 
    650 	if v.TokenCode != nil {
    651 		objectKey := object.Key("TokenCode")
    652 		objectKey.String(*v.TokenCode)
    653 	}
    654 
    655 	if v.TransitiveTagKeys != nil {
    656 		objectKey := object.Key("TransitiveTagKeys")
    657 		if err := awsAwsquery_serializeDocumentTagKeyListType(v.TransitiveTagKeys, objectKey); err != nil {
    658 			return err
    659 		}
    660 	}
    661 
    662 	return nil
    663 }
    664 
    665 func awsAwsquery_serializeOpDocumentAssumeRoleWithSAMLInput(v *AssumeRoleWithSAMLInput, value query.Value) error {
    666 	object := value.Object()
    667 	_ = object
    668 
    669 	if v.DurationSeconds != nil {
    670 		objectKey := object.Key("DurationSeconds")
    671 		objectKey.Integer(*v.DurationSeconds)
    672 	}
    673 
    674 	if v.Policy != nil {
    675 		objectKey := object.Key("Policy")
    676 		objectKey.String(*v.Policy)
    677 	}
    678 
    679 	if v.PolicyArns != nil {
    680 		objectKey := object.Key("PolicyArns")
    681 		if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
    682 			return err
    683 		}
    684 	}
    685 
    686 	if v.PrincipalArn != nil {
    687 		objectKey := object.Key("PrincipalArn")
    688 		objectKey.String(*v.PrincipalArn)
    689 	}
    690 
    691 	if v.RoleArn != nil {
    692 		objectKey := object.Key("RoleArn")
    693 		objectKey.String(*v.RoleArn)
    694 	}
    695 
    696 	if v.SAMLAssertion != nil {
    697 		objectKey := object.Key("SAMLAssertion")
    698 		objectKey.String(*v.SAMLAssertion)
    699 	}
    700 
    701 	return nil
    702 }
    703 
    704 func awsAwsquery_serializeOpDocumentAssumeRoleWithWebIdentityInput(v *AssumeRoleWithWebIdentityInput, value query.Value) error {
    705 	object := value.Object()
    706 	_ = object
    707 
    708 	if v.DurationSeconds != nil {
    709 		objectKey := object.Key("DurationSeconds")
    710 		objectKey.Integer(*v.DurationSeconds)
    711 	}
    712 
    713 	if v.Policy != nil {
    714 		objectKey := object.Key("Policy")
    715 		objectKey.String(*v.Policy)
    716 	}
    717 
    718 	if v.PolicyArns != nil {
    719 		objectKey := object.Key("PolicyArns")
    720 		if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
    721 			return err
    722 		}
    723 	}
    724 
    725 	if v.ProviderId != nil {
    726 		objectKey := object.Key("ProviderId")
    727 		objectKey.String(*v.ProviderId)
    728 	}
    729 
    730 	if v.RoleArn != nil {
    731 		objectKey := object.Key("RoleArn")
    732 		objectKey.String(*v.RoleArn)
    733 	}
    734 
    735 	if v.RoleSessionName != nil {
    736 		objectKey := object.Key("RoleSessionName")
    737 		objectKey.String(*v.RoleSessionName)
    738 	}
    739 
    740 	if v.WebIdentityToken != nil {
    741 		objectKey := object.Key("WebIdentityToken")
    742 		objectKey.String(*v.WebIdentityToken)
    743 	}
    744 
    745 	return nil
    746 }
    747 
    748 func awsAwsquery_serializeOpDocumentDecodeAuthorizationMessageInput(v *DecodeAuthorizationMessageInput, value query.Value) error {
    749 	object := value.Object()
    750 	_ = object
    751 
    752 	if v.EncodedMessage != nil {
    753 		objectKey := object.Key("EncodedMessage")
    754 		objectKey.String(*v.EncodedMessage)
    755 	}
    756 
    757 	return nil
    758 }
    759 
    760 func awsAwsquery_serializeOpDocumentGetAccessKeyInfoInput(v *GetAccessKeyInfoInput, value query.Value) error {
    761 	object := value.Object()
    762 	_ = object
    763 
    764 	if v.AccessKeyId != nil {
    765 		objectKey := object.Key("AccessKeyId")
    766 		objectKey.String(*v.AccessKeyId)
    767 	}
    768 
    769 	return nil
    770 }
    771 
    772 func awsAwsquery_serializeOpDocumentGetCallerIdentityInput(v *GetCallerIdentityInput, value query.Value) error {
    773 	object := value.Object()
    774 	_ = object
    775 
    776 	return nil
    777 }
    778 
    779 func awsAwsquery_serializeOpDocumentGetFederationTokenInput(v *GetFederationTokenInput, value query.Value) error {
    780 	object := value.Object()
    781 	_ = object
    782 
    783 	if v.DurationSeconds != nil {
    784 		objectKey := object.Key("DurationSeconds")
    785 		objectKey.Integer(*v.DurationSeconds)
    786 	}
    787 
    788 	if v.Name != nil {
    789 		objectKey := object.Key("Name")
    790 		objectKey.String(*v.Name)
    791 	}
    792 
    793 	if v.Policy != nil {
    794 		objectKey := object.Key("Policy")
    795 		objectKey.String(*v.Policy)
    796 	}
    797 
    798 	if v.PolicyArns != nil {
    799 		objectKey := object.Key("PolicyArns")
    800 		if err := awsAwsquery_serializeDocumentPolicyDescriptorListType(v.PolicyArns, objectKey); err != nil {
    801 			return err
    802 		}
    803 	}
    804 
    805 	if v.Tags != nil {
    806 		objectKey := object.Key("Tags")
    807 		if err := awsAwsquery_serializeDocumentTagListType(v.Tags, objectKey); err != nil {
    808 			return err
    809 		}
    810 	}
    811 
    812 	return nil
    813 }
    814 
    815 func awsAwsquery_serializeOpDocumentGetSessionTokenInput(v *GetSessionTokenInput, value query.Value) error {
    816 	object := value.Object()
    817 	_ = object
    818 
    819 	if v.DurationSeconds != nil {
    820 		objectKey := object.Key("DurationSeconds")
    821 		objectKey.Integer(*v.DurationSeconds)
    822 	}
    823 
    824 	if v.SerialNumber != nil {
    825 		objectKey := object.Key("SerialNumber")
    826 		objectKey.String(*v.SerialNumber)
    827 	}
    828 
    829 	if v.TokenCode != nil {
    830 		objectKey := object.Key("TokenCode")
    831 		objectKey.String(*v.TokenCode)
    832 	}
    833 
    834 	return nil
    835 }