1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package elasticloadbalancingv2 4 5import ( 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/elasticloadbalancingv2/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 "sort" 16) 17 18type awsAwsquery_serializeOpAddListenerCertificates struct { 19} 20 21func (*awsAwsquery_serializeOpAddListenerCertificates) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsAwsquery_serializeOpAddListenerCertificates) 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.(*AddListenerCertificatesInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 request.Request.URL.Path = "/" 40 request.Request.Method = "POST" 41 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 42 if err != nil { 43 return out, metadata, &smithy.SerializationError{Err: err} 44 } 45 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 46 47 bodyWriter := bytes.NewBuffer(nil) 48 bodyEncoder := query.NewEncoder(bodyWriter) 49 body := bodyEncoder.Object() 50 body.Key("Action").String("AddListenerCertificates") 51 body.Key("Version").String("2015-12-01") 52 53 if err := awsAwsquery_serializeOpDocumentAddListenerCertificatesInput(input, bodyEncoder.Value); err != nil { 54 return out, metadata, &smithy.SerializationError{Err: err} 55 } 56 57 err = bodyEncoder.Encode() 58 if err != nil { 59 return out, metadata, &smithy.SerializationError{Err: err} 60 } 61 62 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 63 return out, metadata, &smithy.SerializationError{Err: err} 64 } 65 66 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 67 return out, metadata, &smithy.SerializationError{Err: err} 68 } 69 in.Request = request 70 71 return next.HandleSerialize(ctx, in) 72} 73 74type awsAwsquery_serializeOpAddTags struct { 75} 76 77func (*awsAwsquery_serializeOpAddTags) ID() string { 78 return "OperationSerializer" 79} 80 81func (m *awsAwsquery_serializeOpAddTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 82 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 83) { 84 request, ok := in.Request.(*smithyhttp.Request) 85 if !ok { 86 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 87 } 88 89 input, ok := in.Parameters.(*AddTagsInput) 90 _ = input 91 if !ok { 92 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 93 } 94 95 request.Request.URL.Path = "/" 96 request.Request.Method = "POST" 97 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 98 if err != nil { 99 return out, metadata, &smithy.SerializationError{Err: err} 100 } 101 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 102 103 bodyWriter := bytes.NewBuffer(nil) 104 bodyEncoder := query.NewEncoder(bodyWriter) 105 body := bodyEncoder.Object() 106 body.Key("Action").String("AddTags") 107 body.Key("Version").String("2015-12-01") 108 109 if err := awsAwsquery_serializeOpDocumentAddTagsInput(input, bodyEncoder.Value); err != nil { 110 return out, metadata, &smithy.SerializationError{Err: err} 111 } 112 113 err = bodyEncoder.Encode() 114 if err != nil { 115 return out, metadata, &smithy.SerializationError{Err: err} 116 } 117 118 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 119 return out, metadata, &smithy.SerializationError{Err: err} 120 } 121 122 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 123 return out, metadata, &smithy.SerializationError{Err: err} 124 } 125 in.Request = request 126 127 return next.HandleSerialize(ctx, in) 128} 129 130type awsAwsquery_serializeOpCreateListener struct { 131} 132 133func (*awsAwsquery_serializeOpCreateListener) ID() string { 134 return "OperationSerializer" 135} 136 137func (m *awsAwsquery_serializeOpCreateListener) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 138 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 139) { 140 request, ok := in.Request.(*smithyhttp.Request) 141 if !ok { 142 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 143 } 144 145 input, ok := in.Parameters.(*CreateListenerInput) 146 _ = input 147 if !ok { 148 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 149 } 150 151 request.Request.URL.Path = "/" 152 request.Request.Method = "POST" 153 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 154 if err != nil { 155 return out, metadata, &smithy.SerializationError{Err: err} 156 } 157 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 158 159 bodyWriter := bytes.NewBuffer(nil) 160 bodyEncoder := query.NewEncoder(bodyWriter) 161 body := bodyEncoder.Object() 162 body.Key("Action").String("CreateListener") 163 body.Key("Version").String("2015-12-01") 164 165 if err := awsAwsquery_serializeOpDocumentCreateListenerInput(input, bodyEncoder.Value); err != nil { 166 return out, metadata, &smithy.SerializationError{Err: err} 167 } 168 169 err = bodyEncoder.Encode() 170 if err != nil { 171 return out, metadata, &smithy.SerializationError{Err: err} 172 } 173 174 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 175 return out, metadata, &smithy.SerializationError{Err: err} 176 } 177 178 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 179 return out, metadata, &smithy.SerializationError{Err: err} 180 } 181 in.Request = request 182 183 return next.HandleSerialize(ctx, in) 184} 185 186type awsAwsquery_serializeOpCreateLoadBalancer struct { 187} 188 189func (*awsAwsquery_serializeOpCreateLoadBalancer) ID() string { 190 return "OperationSerializer" 191} 192 193func (m *awsAwsquery_serializeOpCreateLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 194 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 195) { 196 request, ok := in.Request.(*smithyhttp.Request) 197 if !ok { 198 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 199 } 200 201 input, ok := in.Parameters.(*CreateLoadBalancerInput) 202 _ = input 203 if !ok { 204 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 205 } 206 207 request.Request.URL.Path = "/" 208 request.Request.Method = "POST" 209 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 210 if err != nil { 211 return out, metadata, &smithy.SerializationError{Err: err} 212 } 213 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 214 215 bodyWriter := bytes.NewBuffer(nil) 216 bodyEncoder := query.NewEncoder(bodyWriter) 217 body := bodyEncoder.Object() 218 body.Key("Action").String("CreateLoadBalancer") 219 body.Key("Version").String("2015-12-01") 220 221 if err := awsAwsquery_serializeOpDocumentCreateLoadBalancerInput(input, bodyEncoder.Value); err != nil { 222 return out, metadata, &smithy.SerializationError{Err: err} 223 } 224 225 err = bodyEncoder.Encode() 226 if err != nil { 227 return out, metadata, &smithy.SerializationError{Err: err} 228 } 229 230 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 231 return out, metadata, &smithy.SerializationError{Err: err} 232 } 233 234 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 235 return out, metadata, &smithy.SerializationError{Err: err} 236 } 237 in.Request = request 238 239 return next.HandleSerialize(ctx, in) 240} 241 242type awsAwsquery_serializeOpCreateRule struct { 243} 244 245func (*awsAwsquery_serializeOpCreateRule) ID() string { 246 return "OperationSerializer" 247} 248 249func (m *awsAwsquery_serializeOpCreateRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 250 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 251) { 252 request, ok := in.Request.(*smithyhttp.Request) 253 if !ok { 254 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 255 } 256 257 input, ok := in.Parameters.(*CreateRuleInput) 258 _ = input 259 if !ok { 260 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 261 } 262 263 request.Request.URL.Path = "/" 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("CreateRule") 275 body.Key("Version").String("2015-12-01") 276 277 if err := awsAwsquery_serializeOpDocumentCreateRuleInput(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 return next.HandleSerialize(ctx, in) 296} 297 298type awsAwsquery_serializeOpCreateTargetGroup struct { 299} 300 301func (*awsAwsquery_serializeOpCreateTargetGroup) ID() string { 302 return "OperationSerializer" 303} 304 305func (m *awsAwsquery_serializeOpCreateTargetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 306 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 307) { 308 request, ok := in.Request.(*smithyhttp.Request) 309 if !ok { 310 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 311 } 312 313 input, ok := in.Parameters.(*CreateTargetGroupInput) 314 _ = input 315 if !ok { 316 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 317 } 318 319 request.Request.URL.Path = "/" 320 request.Request.Method = "POST" 321 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 322 if err != nil { 323 return out, metadata, &smithy.SerializationError{Err: err} 324 } 325 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 326 327 bodyWriter := bytes.NewBuffer(nil) 328 bodyEncoder := query.NewEncoder(bodyWriter) 329 body := bodyEncoder.Object() 330 body.Key("Action").String("CreateTargetGroup") 331 body.Key("Version").String("2015-12-01") 332 333 if err := awsAwsquery_serializeOpDocumentCreateTargetGroupInput(input, bodyEncoder.Value); err != nil { 334 return out, metadata, &smithy.SerializationError{Err: err} 335 } 336 337 err = bodyEncoder.Encode() 338 if err != nil { 339 return out, metadata, &smithy.SerializationError{Err: err} 340 } 341 342 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 343 return out, metadata, &smithy.SerializationError{Err: err} 344 } 345 346 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 347 return out, metadata, &smithy.SerializationError{Err: err} 348 } 349 in.Request = request 350 351 return next.HandleSerialize(ctx, in) 352} 353 354type awsAwsquery_serializeOpDeleteListener struct { 355} 356 357func (*awsAwsquery_serializeOpDeleteListener) ID() string { 358 return "OperationSerializer" 359} 360 361func (m *awsAwsquery_serializeOpDeleteListener) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 362 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 363) { 364 request, ok := in.Request.(*smithyhttp.Request) 365 if !ok { 366 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 367 } 368 369 input, ok := in.Parameters.(*DeleteListenerInput) 370 _ = input 371 if !ok { 372 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 373 } 374 375 request.Request.URL.Path = "/" 376 request.Request.Method = "POST" 377 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 378 if err != nil { 379 return out, metadata, &smithy.SerializationError{Err: err} 380 } 381 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 382 383 bodyWriter := bytes.NewBuffer(nil) 384 bodyEncoder := query.NewEncoder(bodyWriter) 385 body := bodyEncoder.Object() 386 body.Key("Action").String("DeleteListener") 387 body.Key("Version").String("2015-12-01") 388 389 if err := awsAwsquery_serializeOpDocumentDeleteListenerInput(input, bodyEncoder.Value); err != nil { 390 return out, metadata, &smithy.SerializationError{Err: err} 391 } 392 393 err = bodyEncoder.Encode() 394 if err != nil { 395 return out, metadata, &smithy.SerializationError{Err: err} 396 } 397 398 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 399 return out, metadata, &smithy.SerializationError{Err: err} 400 } 401 402 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 403 return out, metadata, &smithy.SerializationError{Err: err} 404 } 405 in.Request = request 406 407 return next.HandleSerialize(ctx, in) 408} 409 410type awsAwsquery_serializeOpDeleteLoadBalancer struct { 411} 412 413func (*awsAwsquery_serializeOpDeleteLoadBalancer) ID() string { 414 return "OperationSerializer" 415} 416 417func (m *awsAwsquery_serializeOpDeleteLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 418 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 419) { 420 request, ok := in.Request.(*smithyhttp.Request) 421 if !ok { 422 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 423 } 424 425 input, ok := in.Parameters.(*DeleteLoadBalancerInput) 426 _ = input 427 if !ok { 428 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 429 } 430 431 request.Request.URL.Path = "/" 432 request.Request.Method = "POST" 433 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 434 if err != nil { 435 return out, metadata, &smithy.SerializationError{Err: err} 436 } 437 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 438 439 bodyWriter := bytes.NewBuffer(nil) 440 bodyEncoder := query.NewEncoder(bodyWriter) 441 body := bodyEncoder.Object() 442 body.Key("Action").String("DeleteLoadBalancer") 443 body.Key("Version").String("2015-12-01") 444 445 if err := awsAwsquery_serializeOpDocumentDeleteLoadBalancerInput(input, bodyEncoder.Value); err != nil { 446 return out, metadata, &smithy.SerializationError{Err: err} 447 } 448 449 err = bodyEncoder.Encode() 450 if err != nil { 451 return out, metadata, &smithy.SerializationError{Err: err} 452 } 453 454 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 455 return out, metadata, &smithy.SerializationError{Err: err} 456 } 457 458 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 459 return out, metadata, &smithy.SerializationError{Err: err} 460 } 461 in.Request = request 462 463 return next.HandleSerialize(ctx, in) 464} 465 466type awsAwsquery_serializeOpDeleteRule struct { 467} 468 469func (*awsAwsquery_serializeOpDeleteRule) ID() string { 470 return "OperationSerializer" 471} 472 473func (m *awsAwsquery_serializeOpDeleteRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 474 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 475) { 476 request, ok := in.Request.(*smithyhttp.Request) 477 if !ok { 478 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 479 } 480 481 input, ok := in.Parameters.(*DeleteRuleInput) 482 _ = input 483 if !ok { 484 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 485 } 486 487 request.Request.URL.Path = "/" 488 request.Request.Method = "POST" 489 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 490 if err != nil { 491 return out, metadata, &smithy.SerializationError{Err: err} 492 } 493 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 494 495 bodyWriter := bytes.NewBuffer(nil) 496 bodyEncoder := query.NewEncoder(bodyWriter) 497 body := bodyEncoder.Object() 498 body.Key("Action").String("DeleteRule") 499 body.Key("Version").String("2015-12-01") 500 501 if err := awsAwsquery_serializeOpDocumentDeleteRuleInput(input, bodyEncoder.Value); err != nil { 502 return out, metadata, &smithy.SerializationError{Err: err} 503 } 504 505 err = bodyEncoder.Encode() 506 if err != nil { 507 return out, metadata, &smithy.SerializationError{Err: err} 508 } 509 510 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 511 return out, metadata, &smithy.SerializationError{Err: err} 512 } 513 514 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 515 return out, metadata, &smithy.SerializationError{Err: err} 516 } 517 in.Request = request 518 519 return next.HandleSerialize(ctx, in) 520} 521 522type awsAwsquery_serializeOpDeleteTargetGroup struct { 523} 524 525func (*awsAwsquery_serializeOpDeleteTargetGroup) ID() string { 526 return "OperationSerializer" 527} 528 529func (m *awsAwsquery_serializeOpDeleteTargetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 530 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 531) { 532 request, ok := in.Request.(*smithyhttp.Request) 533 if !ok { 534 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 535 } 536 537 input, ok := in.Parameters.(*DeleteTargetGroupInput) 538 _ = input 539 if !ok { 540 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 541 } 542 543 request.Request.URL.Path = "/" 544 request.Request.Method = "POST" 545 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 546 if err != nil { 547 return out, metadata, &smithy.SerializationError{Err: err} 548 } 549 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 550 551 bodyWriter := bytes.NewBuffer(nil) 552 bodyEncoder := query.NewEncoder(bodyWriter) 553 body := bodyEncoder.Object() 554 body.Key("Action").String("DeleteTargetGroup") 555 body.Key("Version").String("2015-12-01") 556 557 if err := awsAwsquery_serializeOpDocumentDeleteTargetGroupInput(input, bodyEncoder.Value); err != nil { 558 return out, metadata, &smithy.SerializationError{Err: err} 559 } 560 561 err = bodyEncoder.Encode() 562 if err != nil { 563 return out, metadata, &smithy.SerializationError{Err: err} 564 } 565 566 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 567 return out, metadata, &smithy.SerializationError{Err: err} 568 } 569 570 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 571 return out, metadata, &smithy.SerializationError{Err: err} 572 } 573 in.Request = request 574 575 return next.HandleSerialize(ctx, in) 576} 577 578type awsAwsquery_serializeOpDeregisterTargets struct { 579} 580 581func (*awsAwsquery_serializeOpDeregisterTargets) ID() string { 582 return "OperationSerializer" 583} 584 585func (m *awsAwsquery_serializeOpDeregisterTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 586 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 587) { 588 request, ok := in.Request.(*smithyhttp.Request) 589 if !ok { 590 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 591 } 592 593 input, ok := in.Parameters.(*DeregisterTargetsInput) 594 _ = input 595 if !ok { 596 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 597 } 598 599 request.Request.URL.Path = "/" 600 request.Request.Method = "POST" 601 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 602 if err != nil { 603 return out, metadata, &smithy.SerializationError{Err: err} 604 } 605 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 606 607 bodyWriter := bytes.NewBuffer(nil) 608 bodyEncoder := query.NewEncoder(bodyWriter) 609 body := bodyEncoder.Object() 610 body.Key("Action").String("DeregisterTargets") 611 body.Key("Version").String("2015-12-01") 612 613 if err := awsAwsquery_serializeOpDocumentDeregisterTargetsInput(input, bodyEncoder.Value); err != nil { 614 return out, metadata, &smithy.SerializationError{Err: err} 615 } 616 617 err = bodyEncoder.Encode() 618 if err != nil { 619 return out, metadata, &smithy.SerializationError{Err: err} 620 } 621 622 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 623 return out, metadata, &smithy.SerializationError{Err: err} 624 } 625 626 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 627 return out, metadata, &smithy.SerializationError{Err: err} 628 } 629 in.Request = request 630 631 return next.HandleSerialize(ctx, in) 632} 633 634type awsAwsquery_serializeOpDescribeAccountLimits struct { 635} 636 637func (*awsAwsquery_serializeOpDescribeAccountLimits) ID() string { 638 return "OperationSerializer" 639} 640 641func (m *awsAwsquery_serializeOpDescribeAccountLimits) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 642 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 643) { 644 request, ok := in.Request.(*smithyhttp.Request) 645 if !ok { 646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 647 } 648 649 input, ok := in.Parameters.(*DescribeAccountLimitsInput) 650 _ = input 651 if !ok { 652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 653 } 654 655 request.Request.URL.Path = "/" 656 request.Request.Method = "POST" 657 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 658 if err != nil { 659 return out, metadata, &smithy.SerializationError{Err: err} 660 } 661 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 662 663 bodyWriter := bytes.NewBuffer(nil) 664 bodyEncoder := query.NewEncoder(bodyWriter) 665 body := bodyEncoder.Object() 666 body.Key("Action").String("DescribeAccountLimits") 667 body.Key("Version").String("2015-12-01") 668 669 if err := awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(input, bodyEncoder.Value); err != nil { 670 return out, metadata, &smithy.SerializationError{Err: err} 671 } 672 673 err = bodyEncoder.Encode() 674 if err != nil { 675 return out, metadata, &smithy.SerializationError{Err: err} 676 } 677 678 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 679 return out, metadata, &smithy.SerializationError{Err: err} 680 } 681 682 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 683 return out, metadata, &smithy.SerializationError{Err: err} 684 } 685 in.Request = request 686 687 return next.HandleSerialize(ctx, in) 688} 689 690type awsAwsquery_serializeOpDescribeListenerCertificates struct { 691} 692 693func (*awsAwsquery_serializeOpDescribeListenerCertificates) ID() string { 694 return "OperationSerializer" 695} 696 697func (m *awsAwsquery_serializeOpDescribeListenerCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 698 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 699) { 700 request, ok := in.Request.(*smithyhttp.Request) 701 if !ok { 702 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 703 } 704 705 input, ok := in.Parameters.(*DescribeListenerCertificatesInput) 706 _ = input 707 if !ok { 708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 709 } 710 711 request.Request.URL.Path = "/" 712 request.Request.Method = "POST" 713 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 714 if err != nil { 715 return out, metadata, &smithy.SerializationError{Err: err} 716 } 717 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 718 719 bodyWriter := bytes.NewBuffer(nil) 720 bodyEncoder := query.NewEncoder(bodyWriter) 721 body := bodyEncoder.Object() 722 body.Key("Action").String("DescribeListenerCertificates") 723 body.Key("Version").String("2015-12-01") 724 725 if err := awsAwsquery_serializeOpDocumentDescribeListenerCertificatesInput(input, bodyEncoder.Value); err != nil { 726 return out, metadata, &smithy.SerializationError{Err: err} 727 } 728 729 err = bodyEncoder.Encode() 730 if err != nil { 731 return out, metadata, &smithy.SerializationError{Err: err} 732 } 733 734 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 735 return out, metadata, &smithy.SerializationError{Err: err} 736 } 737 738 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 739 return out, metadata, &smithy.SerializationError{Err: err} 740 } 741 in.Request = request 742 743 return next.HandleSerialize(ctx, in) 744} 745 746type awsAwsquery_serializeOpDescribeListeners struct { 747} 748 749func (*awsAwsquery_serializeOpDescribeListeners) ID() string { 750 return "OperationSerializer" 751} 752 753func (m *awsAwsquery_serializeOpDescribeListeners) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 754 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 755) { 756 request, ok := in.Request.(*smithyhttp.Request) 757 if !ok { 758 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 759 } 760 761 input, ok := in.Parameters.(*DescribeListenersInput) 762 _ = input 763 if !ok { 764 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 765 } 766 767 request.Request.URL.Path = "/" 768 request.Request.Method = "POST" 769 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 770 if err != nil { 771 return out, metadata, &smithy.SerializationError{Err: err} 772 } 773 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 774 775 bodyWriter := bytes.NewBuffer(nil) 776 bodyEncoder := query.NewEncoder(bodyWriter) 777 body := bodyEncoder.Object() 778 body.Key("Action").String("DescribeListeners") 779 body.Key("Version").String("2015-12-01") 780 781 if err := awsAwsquery_serializeOpDocumentDescribeListenersInput(input, bodyEncoder.Value); err != nil { 782 return out, metadata, &smithy.SerializationError{Err: err} 783 } 784 785 err = bodyEncoder.Encode() 786 if err != nil { 787 return out, metadata, &smithy.SerializationError{Err: err} 788 } 789 790 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 791 return out, metadata, &smithy.SerializationError{Err: err} 792 } 793 794 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 795 return out, metadata, &smithy.SerializationError{Err: err} 796 } 797 in.Request = request 798 799 return next.HandleSerialize(ctx, in) 800} 801 802type awsAwsquery_serializeOpDescribeLoadBalancerAttributes struct { 803} 804 805func (*awsAwsquery_serializeOpDescribeLoadBalancerAttributes) ID() string { 806 return "OperationSerializer" 807} 808 809func (m *awsAwsquery_serializeOpDescribeLoadBalancerAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 810 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 811) { 812 request, ok := in.Request.(*smithyhttp.Request) 813 if !ok { 814 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 815 } 816 817 input, ok := in.Parameters.(*DescribeLoadBalancerAttributesInput) 818 _ = input 819 if !ok { 820 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 821 } 822 823 request.Request.URL.Path = "/" 824 request.Request.Method = "POST" 825 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 826 if err != nil { 827 return out, metadata, &smithy.SerializationError{Err: err} 828 } 829 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 830 831 bodyWriter := bytes.NewBuffer(nil) 832 bodyEncoder := query.NewEncoder(bodyWriter) 833 body := bodyEncoder.Object() 834 body.Key("Action").String("DescribeLoadBalancerAttributes") 835 body.Key("Version").String("2015-12-01") 836 837 if err := awsAwsquery_serializeOpDocumentDescribeLoadBalancerAttributesInput(input, bodyEncoder.Value); err != nil { 838 return out, metadata, &smithy.SerializationError{Err: err} 839 } 840 841 err = bodyEncoder.Encode() 842 if err != nil { 843 return out, metadata, &smithy.SerializationError{Err: err} 844 } 845 846 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 847 return out, metadata, &smithy.SerializationError{Err: err} 848 } 849 850 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 851 return out, metadata, &smithy.SerializationError{Err: err} 852 } 853 in.Request = request 854 855 return next.HandleSerialize(ctx, in) 856} 857 858type awsAwsquery_serializeOpDescribeLoadBalancers struct { 859} 860 861func (*awsAwsquery_serializeOpDescribeLoadBalancers) ID() string { 862 return "OperationSerializer" 863} 864 865func (m *awsAwsquery_serializeOpDescribeLoadBalancers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 866 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 867) { 868 request, ok := in.Request.(*smithyhttp.Request) 869 if !ok { 870 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 871 } 872 873 input, ok := in.Parameters.(*DescribeLoadBalancersInput) 874 _ = input 875 if !ok { 876 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 877 } 878 879 request.Request.URL.Path = "/" 880 request.Request.Method = "POST" 881 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 882 if err != nil { 883 return out, metadata, &smithy.SerializationError{Err: err} 884 } 885 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 886 887 bodyWriter := bytes.NewBuffer(nil) 888 bodyEncoder := query.NewEncoder(bodyWriter) 889 body := bodyEncoder.Object() 890 body.Key("Action").String("DescribeLoadBalancers") 891 body.Key("Version").String("2015-12-01") 892 893 if err := awsAwsquery_serializeOpDocumentDescribeLoadBalancersInput(input, bodyEncoder.Value); err != nil { 894 return out, metadata, &smithy.SerializationError{Err: err} 895 } 896 897 err = bodyEncoder.Encode() 898 if err != nil { 899 return out, metadata, &smithy.SerializationError{Err: err} 900 } 901 902 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 903 return out, metadata, &smithy.SerializationError{Err: err} 904 } 905 906 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 907 return out, metadata, &smithy.SerializationError{Err: err} 908 } 909 in.Request = request 910 911 return next.HandleSerialize(ctx, in) 912} 913 914type awsAwsquery_serializeOpDescribeRules struct { 915} 916 917func (*awsAwsquery_serializeOpDescribeRules) ID() string { 918 return "OperationSerializer" 919} 920 921func (m *awsAwsquery_serializeOpDescribeRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 922 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 923) { 924 request, ok := in.Request.(*smithyhttp.Request) 925 if !ok { 926 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 927 } 928 929 input, ok := in.Parameters.(*DescribeRulesInput) 930 _ = input 931 if !ok { 932 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 933 } 934 935 request.Request.URL.Path = "/" 936 request.Request.Method = "POST" 937 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 938 if err != nil { 939 return out, metadata, &smithy.SerializationError{Err: err} 940 } 941 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 942 943 bodyWriter := bytes.NewBuffer(nil) 944 bodyEncoder := query.NewEncoder(bodyWriter) 945 body := bodyEncoder.Object() 946 body.Key("Action").String("DescribeRules") 947 body.Key("Version").String("2015-12-01") 948 949 if err := awsAwsquery_serializeOpDocumentDescribeRulesInput(input, bodyEncoder.Value); err != nil { 950 return out, metadata, &smithy.SerializationError{Err: err} 951 } 952 953 err = bodyEncoder.Encode() 954 if err != nil { 955 return out, metadata, &smithy.SerializationError{Err: err} 956 } 957 958 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 959 return out, metadata, &smithy.SerializationError{Err: err} 960 } 961 962 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 963 return out, metadata, &smithy.SerializationError{Err: err} 964 } 965 in.Request = request 966 967 return next.HandleSerialize(ctx, in) 968} 969 970type awsAwsquery_serializeOpDescribeSSLPolicies struct { 971} 972 973func (*awsAwsquery_serializeOpDescribeSSLPolicies) ID() string { 974 return "OperationSerializer" 975} 976 977func (m *awsAwsquery_serializeOpDescribeSSLPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 978 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 979) { 980 request, ok := in.Request.(*smithyhttp.Request) 981 if !ok { 982 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 983 } 984 985 input, ok := in.Parameters.(*DescribeSSLPoliciesInput) 986 _ = input 987 if !ok { 988 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 989 } 990 991 request.Request.URL.Path = "/" 992 request.Request.Method = "POST" 993 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 994 if err != nil { 995 return out, metadata, &smithy.SerializationError{Err: err} 996 } 997 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 998 999 bodyWriter := bytes.NewBuffer(nil) 1000 bodyEncoder := query.NewEncoder(bodyWriter) 1001 body := bodyEncoder.Object() 1002 body.Key("Action").String("DescribeSSLPolicies") 1003 body.Key("Version").String("2015-12-01") 1004 1005 if err := awsAwsquery_serializeOpDocumentDescribeSSLPoliciesInput(input, bodyEncoder.Value); err != nil { 1006 return out, metadata, &smithy.SerializationError{Err: err} 1007 } 1008 1009 err = bodyEncoder.Encode() 1010 if err != nil { 1011 return out, metadata, &smithy.SerializationError{Err: err} 1012 } 1013 1014 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1015 return out, metadata, &smithy.SerializationError{Err: err} 1016 } 1017 1018 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1019 return out, metadata, &smithy.SerializationError{Err: err} 1020 } 1021 in.Request = request 1022 1023 return next.HandleSerialize(ctx, in) 1024} 1025 1026type awsAwsquery_serializeOpDescribeTags struct { 1027} 1028 1029func (*awsAwsquery_serializeOpDescribeTags) ID() string { 1030 return "OperationSerializer" 1031} 1032 1033func (m *awsAwsquery_serializeOpDescribeTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1034 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1035) { 1036 request, ok := in.Request.(*smithyhttp.Request) 1037 if !ok { 1038 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1039 } 1040 1041 input, ok := in.Parameters.(*DescribeTagsInput) 1042 _ = input 1043 if !ok { 1044 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1045 } 1046 1047 request.Request.URL.Path = "/" 1048 request.Request.Method = "POST" 1049 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1050 if err != nil { 1051 return out, metadata, &smithy.SerializationError{Err: err} 1052 } 1053 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1054 1055 bodyWriter := bytes.NewBuffer(nil) 1056 bodyEncoder := query.NewEncoder(bodyWriter) 1057 body := bodyEncoder.Object() 1058 body.Key("Action").String("DescribeTags") 1059 body.Key("Version").String("2015-12-01") 1060 1061 if err := awsAwsquery_serializeOpDocumentDescribeTagsInput(input, bodyEncoder.Value); err != nil { 1062 return out, metadata, &smithy.SerializationError{Err: err} 1063 } 1064 1065 err = bodyEncoder.Encode() 1066 if err != nil { 1067 return out, metadata, &smithy.SerializationError{Err: err} 1068 } 1069 1070 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1071 return out, metadata, &smithy.SerializationError{Err: err} 1072 } 1073 1074 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1075 return out, metadata, &smithy.SerializationError{Err: err} 1076 } 1077 in.Request = request 1078 1079 return next.HandleSerialize(ctx, in) 1080} 1081 1082type awsAwsquery_serializeOpDescribeTargetGroupAttributes struct { 1083} 1084 1085func (*awsAwsquery_serializeOpDescribeTargetGroupAttributes) ID() string { 1086 return "OperationSerializer" 1087} 1088 1089func (m *awsAwsquery_serializeOpDescribeTargetGroupAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1090 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1091) { 1092 request, ok := in.Request.(*smithyhttp.Request) 1093 if !ok { 1094 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1095 } 1096 1097 input, ok := in.Parameters.(*DescribeTargetGroupAttributesInput) 1098 _ = input 1099 if !ok { 1100 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1101 } 1102 1103 request.Request.URL.Path = "/" 1104 request.Request.Method = "POST" 1105 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1106 if err != nil { 1107 return out, metadata, &smithy.SerializationError{Err: err} 1108 } 1109 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1110 1111 bodyWriter := bytes.NewBuffer(nil) 1112 bodyEncoder := query.NewEncoder(bodyWriter) 1113 body := bodyEncoder.Object() 1114 body.Key("Action").String("DescribeTargetGroupAttributes") 1115 body.Key("Version").String("2015-12-01") 1116 1117 if err := awsAwsquery_serializeOpDocumentDescribeTargetGroupAttributesInput(input, bodyEncoder.Value); err != nil { 1118 return out, metadata, &smithy.SerializationError{Err: err} 1119 } 1120 1121 err = bodyEncoder.Encode() 1122 if err != nil { 1123 return out, metadata, &smithy.SerializationError{Err: err} 1124 } 1125 1126 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1127 return out, metadata, &smithy.SerializationError{Err: err} 1128 } 1129 1130 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1131 return out, metadata, &smithy.SerializationError{Err: err} 1132 } 1133 in.Request = request 1134 1135 return next.HandleSerialize(ctx, in) 1136} 1137 1138type awsAwsquery_serializeOpDescribeTargetGroups struct { 1139} 1140 1141func (*awsAwsquery_serializeOpDescribeTargetGroups) ID() string { 1142 return "OperationSerializer" 1143} 1144 1145func (m *awsAwsquery_serializeOpDescribeTargetGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1146 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1147) { 1148 request, ok := in.Request.(*smithyhttp.Request) 1149 if !ok { 1150 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1151 } 1152 1153 input, ok := in.Parameters.(*DescribeTargetGroupsInput) 1154 _ = input 1155 if !ok { 1156 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1157 } 1158 1159 request.Request.URL.Path = "/" 1160 request.Request.Method = "POST" 1161 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1162 if err != nil { 1163 return out, metadata, &smithy.SerializationError{Err: err} 1164 } 1165 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1166 1167 bodyWriter := bytes.NewBuffer(nil) 1168 bodyEncoder := query.NewEncoder(bodyWriter) 1169 body := bodyEncoder.Object() 1170 body.Key("Action").String("DescribeTargetGroups") 1171 body.Key("Version").String("2015-12-01") 1172 1173 if err := awsAwsquery_serializeOpDocumentDescribeTargetGroupsInput(input, bodyEncoder.Value); err != nil { 1174 return out, metadata, &smithy.SerializationError{Err: err} 1175 } 1176 1177 err = bodyEncoder.Encode() 1178 if err != nil { 1179 return out, metadata, &smithy.SerializationError{Err: err} 1180 } 1181 1182 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1183 return out, metadata, &smithy.SerializationError{Err: err} 1184 } 1185 1186 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1187 return out, metadata, &smithy.SerializationError{Err: err} 1188 } 1189 in.Request = request 1190 1191 return next.HandleSerialize(ctx, in) 1192} 1193 1194type awsAwsquery_serializeOpDescribeTargetHealth struct { 1195} 1196 1197func (*awsAwsquery_serializeOpDescribeTargetHealth) ID() string { 1198 return "OperationSerializer" 1199} 1200 1201func (m *awsAwsquery_serializeOpDescribeTargetHealth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1202 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1203) { 1204 request, ok := in.Request.(*smithyhttp.Request) 1205 if !ok { 1206 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1207 } 1208 1209 input, ok := in.Parameters.(*DescribeTargetHealthInput) 1210 _ = input 1211 if !ok { 1212 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1213 } 1214 1215 request.Request.URL.Path = "/" 1216 request.Request.Method = "POST" 1217 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1218 if err != nil { 1219 return out, metadata, &smithy.SerializationError{Err: err} 1220 } 1221 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1222 1223 bodyWriter := bytes.NewBuffer(nil) 1224 bodyEncoder := query.NewEncoder(bodyWriter) 1225 body := bodyEncoder.Object() 1226 body.Key("Action").String("DescribeTargetHealth") 1227 body.Key("Version").String("2015-12-01") 1228 1229 if err := awsAwsquery_serializeOpDocumentDescribeTargetHealthInput(input, bodyEncoder.Value); err != nil { 1230 return out, metadata, &smithy.SerializationError{Err: err} 1231 } 1232 1233 err = bodyEncoder.Encode() 1234 if err != nil { 1235 return out, metadata, &smithy.SerializationError{Err: err} 1236 } 1237 1238 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1239 return out, metadata, &smithy.SerializationError{Err: err} 1240 } 1241 1242 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1243 return out, metadata, &smithy.SerializationError{Err: err} 1244 } 1245 in.Request = request 1246 1247 return next.HandleSerialize(ctx, in) 1248} 1249 1250type awsAwsquery_serializeOpModifyListener struct { 1251} 1252 1253func (*awsAwsquery_serializeOpModifyListener) ID() string { 1254 return "OperationSerializer" 1255} 1256 1257func (m *awsAwsquery_serializeOpModifyListener) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1258 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1259) { 1260 request, ok := in.Request.(*smithyhttp.Request) 1261 if !ok { 1262 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1263 } 1264 1265 input, ok := in.Parameters.(*ModifyListenerInput) 1266 _ = input 1267 if !ok { 1268 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1269 } 1270 1271 request.Request.URL.Path = "/" 1272 request.Request.Method = "POST" 1273 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1274 if err != nil { 1275 return out, metadata, &smithy.SerializationError{Err: err} 1276 } 1277 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1278 1279 bodyWriter := bytes.NewBuffer(nil) 1280 bodyEncoder := query.NewEncoder(bodyWriter) 1281 body := bodyEncoder.Object() 1282 body.Key("Action").String("ModifyListener") 1283 body.Key("Version").String("2015-12-01") 1284 1285 if err := awsAwsquery_serializeOpDocumentModifyListenerInput(input, bodyEncoder.Value); err != nil { 1286 return out, metadata, &smithy.SerializationError{Err: err} 1287 } 1288 1289 err = bodyEncoder.Encode() 1290 if err != nil { 1291 return out, metadata, &smithy.SerializationError{Err: err} 1292 } 1293 1294 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1295 return out, metadata, &smithy.SerializationError{Err: err} 1296 } 1297 1298 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1299 return out, metadata, &smithy.SerializationError{Err: err} 1300 } 1301 in.Request = request 1302 1303 return next.HandleSerialize(ctx, in) 1304} 1305 1306type awsAwsquery_serializeOpModifyLoadBalancerAttributes struct { 1307} 1308 1309func (*awsAwsquery_serializeOpModifyLoadBalancerAttributes) ID() string { 1310 return "OperationSerializer" 1311} 1312 1313func (m *awsAwsquery_serializeOpModifyLoadBalancerAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1314 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1315) { 1316 request, ok := in.Request.(*smithyhttp.Request) 1317 if !ok { 1318 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1319 } 1320 1321 input, ok := in.Parameters.(*ModifyLoadBalancerAttributesInput) 1322 _ = input 1323 if !ok { 1324 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1325 } 1326 1327 request.Request.URL.Path = "/" 1328 request.Request.Method = "POST" 1329 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1330 if err != nil { 1331 return out, metadata, &smithy.SerializationError{Err: err} 1332 } 1333 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1334 1335 bodyWriter := bytes.NewBuffer(nil) 1336 bodyEncoder := query.NewEncoder(bodyWriter) 1337 body := bodyEncoder.Object() 1338 body.Key("Action").String("ModifyLoadBalancerAttributes") 1339 body.Key("Version").String("2015-12-01") 1340 1341 if err := awsAwsquery_serializeOpDocumentModifyLoadBalancerAttributesInput(input, bodyEncoder.Value); err != nil { 1342 return out, metadata, &smithy.SerializationError{Err: err} 1343 } 1344 1345 err = bodyEncoder.Encode() 1346 if err != nil { 1347 return out, metadata, &smithy.SerializationError{Err: err} 1348 } 1349 1350 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1351 return out, metadata, &smithy.SerializationError{Err: err} 1352 } 1353 1354 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1355 return out, metadata, &smithy.SerializationError{Err: err} 1356 } 1357 in.Request = request 1358 1359 return next.HandleSerialize(ctx, in) 1360} 1361 1362type awsAwsquery_serializeOpModifyRule struct { 1363} 1364 1365func (*awsAwsquery_serializeOpModifyRule) ID() string { 1366 return "OperationSerializer" 1367} 1368 1369func (m *awsAwsquery_serializeOpModifyRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1370 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1371) { 1372 request, ok := in.Request.(*smithyhttp.Request) 1373 if !ok { 1374 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1375 } 1376 1377 input, ok := in.Parameters.(*ModifyRuleInput) 1378 _ = input 1379 if !ok { 1380 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1381 } 1382 1383 request.Request.URL.Path = "/" 1384 request.Request.Method = "POST" 1385 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1386 if err != nil { 1387 return out, metadata, &smithy.SerializationError{Err: err} 1388 } 1389 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1390 1391 bodyWriter := bytes.NewBuffer(nil) 1392 bodyEncoder := query.NewEncoder(bodyWriter) 1393 body := bodyEncoder.Object() 1394 body.Key("Action").String("ModifyRule") 1395 body.Key("Version").String("2015-12-01") 1396 1397 if err := awsAwsquery_serializeOpDocumentModifyRuleInput(input, bodyEncoder.Value); err != nil { 1398 return out, metadata, &smithy.SerializationError{Err: err} 1399 } 1400 1401 err = bodyEncoder.Encode() 1402 if err != nil { 1403 return out, metadata, &smithy.SerializationError{Err: err} 1404 } 1405 1406 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1407 return out, metadata, &smithy.SerializationError{Err: err} 1408 } 1409 1410 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1411 return out, metadata, &smithy.SerializationError{Err: err} 1412 } 1413 in.Request = request 1414 1415 return next.HandleSerialize(ctx, in) 1416} 1417 1418type awsAwsquery_serializeOpModifyTargetGroup struct { 1419} 1420 1421func (*awsAwsquery_serializeOpModifyTargetGroup) ID() string { 1422 return "OperationSerializer" 1423} 1424 1425func (m *awsAwsquery_serializeOpModifyTargetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1426 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1427) { 1428 request, ok := in.Request.(*smithyhttp.Request) 1429 if !ok { 1430 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1431 } 1432 1433 input, ok := in.Parameters.(*ModifyTargetGroupInput) 1434 _ = input 1435 if !ok { 1436 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1437 } 1438 1439 request.Request.URL.Path = "/" 1440 request.Request.Method = "POST" 1441 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1442 if err != nil { 1443 return out, metadata, &smithy.SerializationError{Err: err} 1444 } 1445 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1446 1447 bodyWriter := bytes.NewBuffer(nil) 1448 bodyEncoder := query.NewEncoder(bodyWriter) 1449 body := bodyEncoder.Object() 1450 body.Key("Action").String("ModifyTargetGroup") 1451 body.Key("Version").String("2015-12-01") 1452 1453 if err := awsAwsquery_serializeOpDocumentModifyTargetGroupInput(input, bodyEncoder.Value); err != nil { 1454 return out, metadata, &smithy.SerializationError{Err: err} 1455 } 1456 1457 err = bodyEncoder.Encode() 1458 if err != nil { 1459 return out, metadata, &smithy.SerializationError{Err: err} 1460 } 1461 1462 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1463 return out, metadata, &smithy.SerializationError{Err: err} 1464 } 1465 1466 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1467 return out, metadata, &smithy.SerializationError{Err: err} 1468 } 1469 in.Request = request 1470 1471 return next.HandleSerialize(ctx, in) 1472} 1473 1474type awsAwsquery_serializeOpModifyTargetGroupAttributes struct { 1475} 1476 1477func (*awsAwsquery_serializeOpModifyTargetGroupAttributes) ID() string { 1478 return "OperationSerializer" 1479} 1480 1481func (m *awsAwsquery_serializeOpModifyTargetGroupAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1482 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1483) { 1484 request, ok := in.Request.(*smithyhttp.Request) 1485 if !ok { 1486 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1487 } 1488 1489 input, ok := in.Parameters.(*ModifyTargetGroupAttributesInput) 1490 _ = input 1491 if !ok { 1492 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1493 } 1494 1495 request.Request.URL.Path = "/" 1496 request.Request.Method = "POST" 1497 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1498 if err != nil { 1499 return out, metadata, &smithy.SerializationError{Err: err} 1500 } 1501 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1502 1503 bodyWriter := bytes.NewBuffer(nil) 1504 bodyEncoder := query.NewEncoder(bodyWriter) 1505 body := bodyEncoder.Object() 1506 body.Key("Action").String("ModifyTargetGroupAttributes") 1507 body.Key("Version").String("2015-12-01") 1508 1509 if err := awsAwsquery_serializeOpDocumentModifyTargetGroupAttributesInput(input, bodyEncoder.Value); err != nil { 1510 return out, metadata, &smithy.SerializationError{Err: err} 1511 } 1512 1513 err = bodyEncoder.Encode() 1514 if err != nil { 1515 return out, metadata, &smithy.SerializationError{Err: err} 1516 } 1517 1518 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1519 return out, metadata, &smithy.SerializationError{Err: err} 1520 } 1521 1522 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1523 return out, metadata, &smithy.SerializationError{Err: err} 1524 } 1525 in.Request = request 1526 1527 return next.HandleSerialize(ctx, in) 1528} 1529 1530type awsAwsquery_serializeOpRegisterTargets struct { 1531} 1532 1533func (*awsAwsquery_serializeOpRegisterTargets) ID() string { 1534 return "OperationSerializer" 1535} 1536 1537func (m *awsAwsquery_serializeOpRegisterTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1538 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1539) { 1540 request, ok := in.Request.(*smithyhttp.Request) 1541 if !ok { 1542 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1543 } 1544 1545 input, ok := in.Parameters.(*RegisterTargetsInput) 1546 _ = input 1547 if !ok { 1548 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1549 } 1550 1551 request.Request.URL.Path = "/" 1552 request.Request.Method = "POST" 1553 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1554 if err != nil { 1555 return out, metadata, &smithy.SerializationError{Err: err} 1556 } 1557 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1558 1559 bodyWriter := bytes.NewBuffer(nil) 1560 bodyEncoder := query.NewEncoder(bodyWriter) 1561 body := bodyEncoder.Object() 1562 body.Key("Action").String("RegisterTargets") 1563 body.Key("Version").String("2015-12-01") 1564 1565 if err := awsAwsquery_serializeOpDocumentRegisterTargetsInput(input, bodyEncoder.Value); err != nil { 1566 return out, metadata, &smithy.SerializationError{Err: err} 1567 } 1568 1569 err = bodyEncoder.Encode() 1570 if err != nil { 1571 return out, metadata, &smithy.SerializationError{Err: err} 1572 } 1573 1574 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1575 return out, metadata, &smithy.SerializationError{Err: err} 1576 } 1577 1578 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1579 return out, metadata, &smithy.SerializationError{Err: err} 1580 } 1581 in.Request = request 1582 1583 return next.HandleSerialize(ctx, in) 1584} 1585 1586type awsAwsquery_serializeOpRemoveListenerCertificates struct { 1587} 1588 1589func (*awsAwsquery_serializeOpRemoveListenerCertificates) ID() string { 1590 return "OperationSerializer" 1591} 1592 1593func (m *awsAwsquery_serializeOpRemoveListenerCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1594 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1595) { 1596 request, ok := in.Request.(*smithyhttp.Request) 1597 if !ok { 1598 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1599 } 1600 1601 input, ok := in.Parameters.(*RemoveListenerCertificatesInput) 1602 _ = input 1603 if !ok { 1604 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1605 } 1606 1607 request.Request.URL.Path = "/" 1608 request.Request.Method = "POST" 1609 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1610 if err != nil { 1611 return out, metadata, &smithy.SerializationError{Err: err} 1612 } 1613 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1614 1615 bodyWriter := bytes.NewBuffer(nil) 1616 bodyEncoder := query.NewEncoder(bodyWriter) 1617 body := bodyEncoder.Object() 1618 body.Key("Action").String("RemoveListenerCertificates") 1619 body.Key("Version").String("2015-12-01") 1620 1621 if err := awsAwsquery_serializeOpDocumentRemoveListenerCertificatesInput(input, bodyEncoder.Value); err != nil { 1622 return out, metadata, &smithy.SerializationError{Err: err} 1623 } 1624 1625 err = bodyEncoder.Encode() 1626 if err != nil { 1627 return out, metadata, &smithy.SerializationError{Err: err} 1628 } 1629 1630 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1631 return out, metadata, &smithy.SerializationError{Err: err} 1632 } 1633 1634 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1635 return out, metadata, &smithy.SerializationError{Err: err} 1636 } 1637 in.Request = request 1638 1639 return next.HandleSerialize(ctx, in) 1640} 1641 1642type awsAwsquery_serializeOpRemoveTags struct { 1643} 1644 1645func (*awsAwsquery_serializeOpRemoveTags) ID() string { 1646 return "OperationSerializer" 1647} 1648 1649func (m *awsAwsquery_serializeOpRemoveTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1650 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1651) { 1652 request, ok := in.Request.(*smithyhttp.Request) 1653 if !ok { 1654 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1655 } 1656 1657 input, ok := in.Parameters.(*RemoveTagsInput) 1658 _ = input 1659 if !ok { 1660 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1661 } 1662 1663 request.Request.URL.Path = "/" 1664 request.Request.Method = "POST" 1665 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1666 if err != nil { 1667 return out, metadata, &smithy.SerializationError{Err: err} 1668 } 1669 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1670 1671 bodyWriter := bytes.NewBuffer(nil) 1672 bodyEncoder := query.NewEncoder(bodyWriter) 1673 body := bodyEncoder.Object() 1674 body.Key("Action").String("RemoveTags") 1675 body.Key("Version").String("2015-12-01") 1676 1677 if err := awsAwsquery_serializeOpDocumentRemoveTagsInput(input, bodyEncoder.Value); err != nil { 1678 return out, metadata, &smithy.SerializationError{Err: err} 1679 } 1680 1681 err = bodyEncoder.Encode() 1682 if err != nil { 1683 return out, metadata, &smithy.SerializationError{Err: err} 1684 } 1685 1686 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1687 return out, metadata, &smithy.SerializationError{Err: err} 1688 } 1689 1690 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1691 return out, metadata, &smithy.SerializationError{Err: err} 1692 } 1693 in.Request = request 1694 1695 return next.HandleSerialize(ctx, in) 1696} 1697 1698type awsAwsquery_serializeOpSetIpAddressType struct { 1699} 1700 1701func (*awsAwsquery_serializeOpSetIpAddressType) ID() string { 1702 return "OperationSerializer" 1703} 1704 1705func (m *awsAwsquery_serializeOpSetIpAddressType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1706 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1707) { 1708 request, ok := in.Request.(*smithyhttp.Request) 1709 if !ok { 1710 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1711 } 1712 1713 input, ok := in.Parameters.(*SetIpAddressTypeInput) 1714 _ = input 1715 if !ok { 1716 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1717 } 1718 1719 request.Request.URL.Path = "/" 1720 request.Request.Method = "POST" 1721 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1722 if err != nil { 1723 return out, metadata, &smithy.SerializationError{Err: err} 1724 } 1725 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1726 1727 bodyWriter := bytes.NewBuffer(nil) 1728 bodyEncoder := query.NewEncoder(bodyWriter) 1729 body := bodyEncoder.Object() 1730 body.Key("Action").String("SetIpAddressType") 1731 body.Key("Version").String("2015-12-01") 1732 1733 if err := awsAwsquery_serializeOpDocumentSetIpAddressTypeInput(input, bodyEncoder.Value); err != nil { 1734 return out, metadata, &smithy.SerializationError{Err: err} 1735 } 1736 1737 err = bodyEncoder.Encode() 1738 if err != nil { 1739 return out, metadata, &smithy.SerializationError{Err: err} 1740 } 1741 1742 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1743 return out, metadata, &smithy.SerializationError{Err: err} 1744 } 1745 1746 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1747 return out, metadata, &smithy.SerializationError{Err: err} 1748 } 1749 in.Request = request 1750 1751 return next.HandleSerialize(ctx, in) 1752} 1753 1754type awsAwsquery_serializeOpSetRulePriorities struct { 1755} 1756 1757func (*awsAwsquery_serializeOpSetRulePriorities) ID() string { 1758 return "OperationSerializer" 1759} 1760 1761func (m *awsAwsquery_serializeOpSetRulePriorities) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1762 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1763) { 1764 request, ok := in.Request.(*smithyhttp.Request) 1765 if !ok { 1766 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1767 } 1768 1769 input, ok := in.Parameters.(*SetRulePrioritiesInput) 1770 _ = input 1771 if !ok { 1772 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1773 } 1774 1775 request.Request.URL.Path = "/" 1776 request.Request.Method = "POST" 1777 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1778 if err != nil { 1779 return out, metadata, &smithy.SerializationError{Err: err} 1780 } 1781 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1782 1783 bodyWriter := bytes.NewBuffer(nil) 1784 bodyEncoder := query.NewEncoder(bodyWriter) 1785 body := bodyEncoder.Object() 1786 body.Key("Action").String("SetRulePriorities") 1787 body.Key("Version").String("2015-12-01") 1788 1789 if err := awsAwsquery_serializeOpDocumentSetRulePrioritiesInput(input, bodyEncoder.Value); err != nil { 1790 return out, metadata, &smithy.SerializationError{Err: err} 1791 } 1792 1793 err = bodyEncoder.Encode() 1794 if err != nil { 1795 return out, metadata, &smithy.SerializationError{Err: err} 1796 } 1797 1798 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1799 return out, metadata, &smithy.SerializationError{Err: err} 1800 } 1801 1802 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1803 return out, metadata, &smithy.SerializationError{Err: err} 1804 } 1805 in.Request = request 1806 1807 return next.HandleSerialize(ctx, in) 1808} 1809 1810type awsAwsquery_serializeOpSetSecurityGroups struct { 1811} 1812 1813func (*awsAwsquery_serializeOpSetSecurityGroups) ID() string { 1814 return "OperationSerializer" 1815} 1816 1817func (m *awsAwsquery_serializeOpSetSecurityGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1818 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1819) { 1820 request, ok := in.Request.(*smithyhttp.Request) 1821 if !ok { 1822 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1823 } 1824 1825 input, ok := in.Parameters.(*SetSecurityGroupsInput) 1826 _ = input 1827 if !ok { 1828 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1829 } 1830 1831 request.Request.URL.Path = "/" 1832 request.Request.Method = "POST" 1833 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1834 if err != nil { 1835 return out, metadata, &smithy.SerializationError{Err: err} 1836 } 1837 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1838 1839 bodyWriter := bytes.NewBuffer(nil) 1840 bodyEncoder := query.NewEncoder(bodyWriter) 1841 body := bodyEncoder.Object() 1842 body.Key("Action").String("SetSecurityGroups") 1843 body.Key("Version").String("2015-12-01") 1844 1845 if err := awsAwsquery_serializeOpDocumentSetSecurityGroupsInput(input, bodyEncoder.Value); err != nil { 1846 return out, metadata, &smithy.SerializationError{Err: err} 1847 } 1848 1849 err = bodyEncoder.Encode() 1850 if err != nil { 1851 return out, metadata, &smithy.SerializationError{Err: err} 1852 } 1853 1854 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1855 return out, metadata, &smithy.SerializationError{Err: err} 1856 } 1857 1858 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1859 return out, metadata, &smithy.SerializationError{Err: err} 1860 } 1861 in.Request = request 1862 1863 return next.HandleSerialize(ctx, in) 1864} 1865 1866type awsAwsquery_serializeOpSetSubnets struct { 1867} 1868 1869func (*awsAwsquery_serializeOpSetSubnets) ID() string { 1870 return "OperationSerializer" 1871} 1872 1873func (m *awsAwsquery_serializeOpSetSubnets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1874 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1875) { 1876 request, ok := in.Request.(*smithyhttp.Request) 1877 if !ok { 1878 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1879 } 1880 1881 input, ok := in.Parameters.(*SetSubnetsInput) 1882 _ = input 1883 if !ok { 1884 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1885 } 1886 1887 request.Request.URL.Path = "/" 1888 request.Request.Method = "POST" 1889 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1890 if err != nil { 1891 return out, metadata, &smithy.SerializationError{Err: err} 1892 } 1893 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1894 1895 bodyWriter := bytes.NewBuffer(nil) 1896 bodyEncoder := query.NewEncoder(bodyWriter) 1897 body := bodyEncoder.Object() 1898 body.Key("Action").String("SetSubnets") 1899 body.Key("Version").String("2015-12-01") 1900 1901 if err := awsAwsquery_serializeOpDocumentSetSubnetsInput(input, bodyEncoder.Value); err != nil { 1902 return out, metadata, &smithy.SerializationError{Err: err} 1903 } 1904 1905 err = bodyEncoder.Encode() 1906 if err != nil { 1907 return out, metadata, &smithy.SerializationError{Err: err} 1908 } 1909 1910 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1911 return out, metadata, &smithy.SerializationError{Err: err} 1912 } 1913 1914 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1915 return out, metadata, &smithy.SerializationError{Err: err} 1916 } 1917 in.Request = request 1918 1919 return next.HandleSerialize(ctx, in) 1920} 1921func awsAwsquery_serializeDocumentAction(v *types.Action, value query.Value) error { 1922 object := value.Object() 1923 _ = object 1924 1925 if v.AuthenticateCognitoConfig != nil { 1926 objectKey := object.Key("AuthenticateCognitoConfig") 1927 if err := awsAwsquery_serializeDocumentAuthenticateCognitoActionConfig(v.AuthenticateCognitoConfig, objectKey); err != nil { 1928 return err 1929 } 1930 } 1931 1932 if v.AuthenticateOidcConfig != nil { 1933 objectKey := object.Key("AuthenticateOidcConfig") 1934 if err := awsAwsquery_serializeDocumentAuthenticateOidcActionConfig(v.AuthenticateOidcConfig, objectKey); err != nil { 1935 return err 1936 } 1937 } 1938 1939 if v.FixedResponseConfig != nil { 1940 objectKey := object.Key("FixedResponseConfig") 1941 if err := awsAwsquery_serializeDocumentFixedResponseActionConfig(v.FixedResponseConfig, objectKey); err != nil { 1942 return err 1943 } 1944 } 1945 1946 if v.ForwardConfig != nil { 1947 objectKey := object.Key("ForwardConfig") 1948 if err := awsAwsquery_serializeDocumentForwardActionConfig(v.ForwardConfig, objectKey); err != nil { 1949 return err 1950 } 1951 } 1952 1953 if v.Order != nil { 1954 objectKey := object.Key("Order") 1955 objectKey.Integer(*v.Order) 1956 } 1957 1958 if v.RedirectConfig != nil { 1959 objectKey := object.Key("RedirectConfig") 1960 if err := awsAwsquery_serializeDocumentRedirectActionConfig(v.RedirectConfig, objectKey); err != nil { 1961 return err 1962 } 1963 } 1964 1965 if v.TargetGroupArn != nil { 1966 objectKey := object.Key("TargetGroupArn") 1967 objectKey.String(*v.TargetGroupArn) 1968 } 1969 1970 if len(v.Type) > 0 { 1971 objectKey := object.Key("Type") 1972 objectKey.String(string(v.Type)) 1973 } 1974 1975 return nil 1976} 1977 1978func awsAwsquery_serializeDocumentActions(v []types.Action, value query.Value) error { 1979 if len(v) == 0 { 1980 return nil 1981 } 1982 array := value.Array("member") 1983 1984 for i := range v { 1985 av := array.Value() 1986 if err := awsAwsquery_serializeDocumentAction(&v[i], av); err != nil { 1987 return err 1988 } 1989 } 1990 return nil 1991} 1992 1993func awsAwsquery_serializeDocumentAlpnPolicyName(v []string, value query.Value) error { 1994 if len(v) == 0 { 1995 return nil 1996 } 1997 array := value.Array("member") 1998 1999 for i := range v { 2000 av := array.Value() 2001 av.String(v[i]) 2002 } 2003 return nil 2004} 2005 2006func awsAwsquery_serializeDocumentAuthenticateCognitoActionAuthenticationRequestExtraParams(v map[string]string, value query.Value) error { 2007 if len(v) == 0 { 2008 return nil 2009 } 2010 object := value.Map("key", "value") 2011 2012 keys := make([]string, 0, len(v)) 2013 for key := range v { 2014 keys = append(keys, key) 2015 } 2016 sort.Strings(keys) 2017 2018 for _, key := range keys { 2019 om := object.Key(key) 2020 om.String(v[key]) 2021 } 2022 return nil 2023} 2024 2025func awsAwsquery_serializeDocumentAuthenticateCognitoActionConfig(v *types.AuthenticateCognitoActionConfig, value query.Value) error { 2026 object := value.Object() 2027 _ = object 2028 2029 if v.AuthenticationRequestExtraParams != nil { 2030 objectKey := object.Key("AuthenticationRequestExtraParams") 2031 if err := awsAwsquery_serializeDocumentAuthenticateCognitoActionAuthenticationRequestExtraParams(v.AuthenticationRequestExtraParams, objectKey); err != nil { 2032 return err 2033 } 2034 } 2035 2036 if len(v.OnUnauthenticatedRequest) > 0 { 2037 objectKey := object.Key("OnUnauthenticatedRequest") 2038 objectKey.String(string(v.OnUnauthenticatedRequest)) 2039 } 2040 2041 if v.Scope != nil { 2042 objectKey := object.Key("Scope") 2043 objectKey.String(*v.Scope) 2044 } 2045 2046 if v.SessionCookieName != nil { 2047 objectKey := object.Key("SessionCookieName") 2048 objectKey.String(*v.SessionCookieName) 2049 } 2050 2051 if v.SessionTimeout != nil { 2052 objectKey := object.Key("SessionTimeout") 2053 objectKey.Long(*v.SessionTimeout) 2054 } 2055 2056 if v.UserPoolArn != nil { 2057 objectKey := object.Key("UserPoolArn") 2058 objectKey.String(*v.UserPoolArn) 2059 } 2060 2061 if v.UserPoolClientId != nil { 2062 objectKey := object.Key("UserPoolClientId") 2063 objectKey.String(*v.UserPoolClientId) 2064 } 2065 2066 if v.UserPoolDomain != nil { 2067 objectKey := object.Key("UserPoolDomain") 2068 objectKey.String(*v.UserPoolDomain) 2069 } 2070 2071 return nil 2072} 2073 2074func awsAwsquery_serializeDocumentAuthenticateOidcActionAuthenticationRequestExtraParams(v map[string]string, value query.Value) error { 2075 if len(v) == 0 { 2076 return nil 2077 } 2078 object := value.Map("key", "value") 2079 2080 keys := make([]string, 0, len(v)) 2081 for key := range v { 2082 keys = append(keys, key) 2083 } 2084 sort.Strings(keys) 2085 2086 for _, key := range keys { 2087 om := object.Key(key) 2088 om.String(v[key]) 2089 } 2090 return nil 2091} 2092 2093func awsAwsquery_serializeDocumentAuthenticateOidcActionConfig(v *types.AuthenticateOidcActionConfig, value query.Value) error { 2094 object := value.Object() 2095 _ = object 2096 2097 if v.AuthenticationRequestExtraParams != nil { 2098 objectKey := object.Key("AuthenticationRequestExtraParams") 2099 if err := awsAwsquery_serializeDocumentAuthenticateOidcActionAuthenticationRequestExtraParams(v.AuthenticationRequestExtraParams, objectKey); err != nil { 2100 return err 2101 } 2102 } 2103 2104 if v.AuthorizationEndpoint != nil { 2105 objectKey := object.Key("AuthorizationEndpoint") 2106 objectKey.String(*v.AuthorizationEndpoint) 2107 } 2108 2109 if v.ClientId != nil { 2110 objectKey := object.Key("ClientId") 2111 objectKey.String(*v.ClientId) 2112 } 2113 2114 if v.ClientSecret != nil { 2115 objectKey := object.Key("ClientSecret") 2116 objectKey.String(*v.ClientSecret) 2117 } 2118 2119 if v.Issuer != nil { 2120 objectKey := object.Key("Issuer") 2121 objectKey.String(*v.Issuer) 2122 } 2123 2124 if len(v.OnUnauthenticatedRequest) > 0 { 2125 objectKey := object.Key("OnUnauthenticatedRequest") 2126 objectKey.String(string(v.OnUnauthenticatedRequest)) 2127 } 2128 2129 if v.Scope != nil { 2130 objectKey := object.Key("Scope") 2131 objectKey.String(*v.Scope) 2132 } 2133 2134 if v.SessionCookieName != nil { 2135 objectKey := object.Key("SessionCookieName") 2136 objectKey.String(*v.SessionCookieName) 2137 } 2138 2139 if v.SessionTimeout != nil { 2140 objectKey := object.Key("SessionTimeout") 2141 objectKey.Long(*v.SessionTimeout) 2142 } 2143 2144 if v.TokenEndpoint != nil { 2145 objectKey := object.Key("TokenEndpoint") 2146 objectKey.String(*v.TokenEndpoint) 2147 } 2148 2149 if v.UseExistingClientSecret != nil { 2150 objectKey := object.Key("UseExistingClientSecret") 2151 objectKey.Boolean(*v.UseExistingClientSecret) 2152 } 2153 2154 if v.UserInfoEndpoint != nil { 2155 objectKey := object.Key("UserInfoEndpoint") 2156 objectKey.String(*v.UserInfoEndpoint) 2157 } 2158 2159 return nil 2160} 2161 2162func awsAwsquery_serializeDocumentCertificate(v *types.Certificate, value query.Value) error { 2163 object := value.Object() 2164 _ = object 2165 2166 if v.CertificateArn != nil { 2167 objectKey := object.Key("CertificateArn") 2168 objectKey.String(*v.CertificateArn) 2169 } 2170 2171 if v.IsDefault != nil { 2172 objectKey := object.Key("IsDefault") 2173 objectKey.Boolean(*v.IsDefault) 2174 } 2175 2176 return nil 2177} 2178 2179func awsAwsquery_serializeDocumentCertificateList(v []types.Certificate, value query.Value) error { 2180 if len(v) == 0 { 2181 return nil 2182 } 2183 array := value.Array("member") 2184 2185 for i := range v { 2186 av := array.Value() 2187 if err := awsAwsquery_serializeDocumentCertificate(&v[i], av); err != nil { 2188 return err 2189 } 2190 } 2191 return nil 2192} 2193 2194func awsAwsquery_serializeDocumentFixedResponseActionConfig(v *types.FixedResponseActionConfig, value query.Value) error { 2195 object := value.Object() 2196 _ = object 2197 2198 if v.ContentType != nil { 2199 objectKey := object.Key("ContentType") 2200 objectKey.String(*v.ContentType) 2201 } 2202 2203 if v.MessageBody != nil { 2204 objectKey := object.Key("MessageBody") 2205 objectKey.String(*v.MessageBody) 2206 } 2207 2208 if v.StatusCode != nil { 2209 objectKey := object.Key("StatusCode") 2210 objectKey.String(*v.StatusCode) 2211 } 2212 2213 return nil 2214} 2215 2216func awsAwsquery_serializeDocumentForwardActionConfig(v *types.ForwardActionConfig, value query.Value) error { 2217 object := value.Object() 2218 _ = object 2219 2220 if v.TargetGroups != nil { 2221 objectKey := object.Key("TargetGroups") 2222 if err := awsAwsquery_serializeDocumentTargetGroupList(v.TargetGroups, objectKey); err != nil { 2223 return err 2224 } 2225 } 2226 2227 if v.TargetGroupStickinessConfig != nil { 2228 objectKey := object.Key("TargetGroupStickinessConfig") 2229 if err := awsAwsquery_serializeDocumentTargetGroupStickinessConfig(v.TargetGroupStickinessConfig, objectKey); err != nil { 2230 return err 2231 } 2232 } 2233 2234 return nil 2235} 2236 2237func awsAwsquery_serializeDocumentHostHeaderConditionConfig(v *types.HostHeaderConditionConfig, value query.Value) error { 2238 object := value.Object() 2239 _ = object 2240 2241 if v.Values != nil { 2242 objectKey := object.Key("Values") 2243 if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil { 2244 return err 2245 } 2246 } 2247 2248 return nil 2249} 2250 2251func awsAwsquery_serializeDocumentHttpHeaderConditionConfig(v *types.HttpHeaderConditionConfig, value query.Value) error { 2252 object := value.Object() 2253 _ = object 2254 2255 if v.HttpHeaderName != nil { 2256 objectKey := object.Key("HttpHeaderName") 2257 objectKey.String(*v.HttpHeaderName) 2258 } 2259 2260 if v.Values != nil { 2261 objectKey := object.Key("Values") 2262 if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil { 2263 return err 2264 } 2265 } 2266 2267 return nil 2268} 2269 2270func awsAwsquery_serializeDocumentHttpRequestMethodConditionConfig(v *types.HttpRequestMethodConditionConfig, value query.Value) error { 2271 object := value.Object() 2272 _ = object 2273 2274 if v.Values != nil { 2275 objectKey := object.Key("Values") 2276 if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil { 2277 return err 2278 } 2279 } 2280 2281 return nil 2282} 2283 2284func awsAwsquery_serializeDocumentListenerArns(v []string, value query.Value) error { 2285 if len(v) == 0 { 2286 return nil 2287 } 2288 array := value.Array("member") 2289 2290 for i := range v { 2291 av := array.Value() 2292 av.String(v[i]) 2293 } 2294 return nil 2295} 2296 2297func awsAwsquery_serializeDocumentListOfString(v []string, value query.Value) error { 2298 if len(v) == 0 { 2299 return nil 2300 } 2301 array := value.Array("member") 2302 2303 for i := range v { 2304 av := array.Value() 2305 av.String(v[i]) 2306 } 2307 return nil 2308} 2309 2310func awsAwsquery_serializeDocumentLoadBalancerArns(v []string, value query.Value) error { 2311 if len(v) == 0 { 2312 return nil 2313 } 2314 array := value.Array("member") 2315 2316 for i := range v { 2317 av := array.Value() 2318 av.String(v[i]) 2319 } 2320 return nil 2321} 2322 2323func awsAwsquery_serializeDocumentLoadBalancerAttribute(v *types.LoadBalancerAttribute, value query.Value) error { 2324 object := value.Object() 2325 _ = object 2326 2327 if v.Key != nil { 2328 objectKey := object.Key("Key") 2329 objectKey.String(*v.Key) 2330 } 2331 2332 if v.Value != nil { 2333 objectKey := object.Key("Value") 2334 objectKey.String(*v.Value) 2335 } 2336 2337 return nil 2338} 2339 2340func awsAwsquery_serializeDocumentLoadBalancerAttributes(v []types.LoadBalancerAttribute, value query.Value) error { 2341 if len(v) == 0 { 2342 return nil 2343 } 2344 array := value.Array("member") 2345 2346 for i := range v { 2347 av := array.Value() 2348 if err := awsAwsquery_serializeDocumentLoadBalancerAttribute(&v[i], av); err != nil { 2349 return err 2350 } 2351 } 2352 return nil 2353} 2354 2355func awsAwsquery_serializeDocumentLoadBalancerNames(v []string, value query.Value) error { 2356 if len(v) == 0 { 2357 return nil 2358 } 2359 array := value.Array("member") 2360 2361 for i := range v { 2362 av := array.Value() 2363 av.String(v[i]) 2364 } 2365 return nil 2366} 2367 2368func awsAwsquery_serializeDocumentMatcher(v *types.Matcher, value query.Value) error { 2369 object := value.Object() 2370 _ = object 2371 2372 if v.GrpcCode != nil { 2373 objectKey := object.Key("GrpcCode") 2374 objectKey.String(*v.GrpcCode) 2375 } 2376 2377 if v.HttpCode != nil { 2378 objectKey := object.Key("HttpCode") 2379 objectKey.String(*v.HttpCode) 2380 } 2381 2382 return nil 2383} 2384 2385func awsAwsquery_serializeDocumentPathPatternConditionConfig(v *types.PathPatternConditionConfig, value query.Value) error { 2386 object := value.Object() 2387 _ = object 2388 2389 if v.Values != nil { 2390 objectKey := object.Key("Values") 2391 if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil { 2392 return err 2393 } 2394 } 2395 2396 return nil 2397} 2398 2399func awsAwsquery_serializeDocumentQueryStringConditionConfig(v *types.QueryStringConditionConfig, value query.Value) error { 2400 object := value.Object() 2401 _ = object 2402 2403 if v.Values != nil { 2404 objectKey := object.Key("Values") 2405 if err := awsAwsquery_serializeDocumentQueryStringKeyValuePairList(v.Values, objectKey); err != nil { 2406 return err 2407 } 2408 } 2409 2410 return nil 2411} 2412 2413func awsAwsquery_serializeDocumentQueryStringKeyValuePair(v *types.QueryStringKeyValuePair, value query.Value) error { 2414 object := value.Object() 2415 _ = object 2416 2417 if v.Key != nil { 2418 objectKey := object.Key("Key") 2419 objectKey.String(*v.Key) 2420 } 2421 2422 if v.Value != nil { 2423 objectKey := object.Key("Value") 2424 objectKey.String(*v.Value) 2425 } 2426 2427 return nil 2428} 2429 2430func awsAwsquery_serializeDocumentQueryStringKeyValuePairList(v []types.QueryStringKeyValuePair, value query.Value) error { 2431 if len(v) == 0 { 2432 return nil 2433 } 2434 array := value.Array("member") 2435 2436 for i := range v { 2437 av := array.Value() 2438 if err := awsAwsquery_serializeDocumentQueryStringKeyValuePair(&v[i], av); err != nil { 2439 return err 2440 } 2441 } 2442 return nil 2443} 2444 2445func awsAwsquery_serializeDocumentRedirectActionConfig(v *types.RedirectActionConfig, value query.Value) error { 2446 object := value.Object() 2447 _ = object 2448 2449 if v.Host != nil { 2450 objectKey := object.Key("Host") 2451 objectKey.String(*v.Host) 2452 } 2453 2454 if v.Path != nil { 2455 objectKey := object.Key("Path") 2456 objectKey.String(*v.Path) 2457 } 2458 2459 if v.Port != nil { 2460 objectKey := object.Key("Port") 2461 objectKey.String(*v.Port) 2462 } 2463 2464 if v.Protocol != nil { 2465 objectKey := object.Key("Protocol") 2466 objectKey.String(*v.Protocol) 2467 } 2468 2469 if v.Query != nil { 2470 objectKey := object.Key("Query") 2471 objectKey.String(*v.Query) 2472 } 2473 2474 if len(v.StatusCode) > 0 { 2475 objectKey := object.Key("StatusCode") 2476 objectKey.String(string(v.StatusCode)) 2477 } 2478 2479 return nil 2480} 2481 2482func awsAwsquery_serializeDocumentResourceArns(v []string, value query.Value) error { 2483 if len(v) == 0 { 2484 return nil 2485 } 2486 array := value.Array("member") 2487 2488 for i := range v { 2489 av := array.Value() 2490 av.String(v[i]) 2491 } 2492 return nil 2493} 2494 2495func awsAwsquery_serializeDocumentRuleArns(v []string, value query.Value) error { 2496 if len(v) == 0 { 2497 return nil 2498 } 2499 array := value.Array("member") 2500 2501 for i := range v { 2502 av := array.Value() 2503 av.String(v[i]) 2504 } 2505 return nil 2506} 2507 2508func awsAwsquery_serializeDocumentRuleCondition(v *types.RuleCondition, value query.Value) error { 2509 object := value.Object() 2510 _ = object 2511 2512 if v.Field != nil { 2513 objectKey := object.Key("Field") 2514 objectKey.String(*v.Field) 2515 } 2516 2517 if v.HostHeaderConfig != nil { 2518 objectKey := object.Key("HostHeaderConfig") 2519 if err := awsAwsquery_serializeDocumentHostHeaderConditionConfig(v.HostHeaderConfig, objectKey); err != nil { 2520 return err 2521 } 2522 } 2523 2524 if v.HttpHeaderConfig != nil { 2525 objectKey := object.Key("HttpHeaderConfig") 2526 if err := awsAwsquery_serializeDocumentHttpHeaderConditionConfig(v.HttpHeaderConfig, objectKey); err != nil { 2527 return err 2528 } 2529 } 2530 2531 if v.HttpRequestMethodConfig != nil { 2532 objectKey := object.Key("HttpRequestMethodConfig") 2533 if err := awsAwsquery_serializeDocumentHttpRequestMethodConditionConfig(v.HttpRequestMethodConfig, objectKey); err != nil { 2534 return err 2535 } 2536 } 2537 2538 if v.PathPatternConfig != nil { 2539 objectKey := object.Key("PathPatternConfig") 2540 if err := awsAwsquery_serializeDocumentPathPatternConditionConfig(v.PathPatternConfig, objectKey); err != nil { 2541 return err 2542 } 2543 } 2544 2545 if v.QueryStringConfig != nil { 2546 objectKey := object.Key("QueryStringConfig") 2547 if err := awsAwsquery_serializeDocumentQueryStringConditionConfig(v.QueryStringConfig, objectKey); err != nil { 2548 return err 2549 } 2550 } 2551 2552 if v.SourceIpConfig != nil { 2553 objectKey := object.Key("SourceIpConfig") 2554 if err := awsAwsquery_serializeDocumentSourceIpConditionConfig(v.SourceIpConfig, objectKey); err != nil { 2555 return err 2556 } 2557 } 2558 2559 if v.Values != nil { 2560 objectKey := object.Key("Values") 2561 if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil { 2562 return err 2563 } 2564 } 2565 2566 return nil 2567} 2568 2569func awsAwsquery_serializeDocumentRuleConditionList(v []types.RuleCondition, value query.Value) error { 2570 if len(v) == 0 { 2571 return nil 2572 } 2573 array := value.Array("member") 2574 2575 for i := range v { 2576 av := array.Value() 2577 if err := awsAwsquery_serializeDocumentRuleCondition(&v[i], av); err != nil { 2578 return err 2579 } 2580 } 2581 return nil 2582} 2583 2584func awsAwsquery_serializeDocumentRulePriorityList(v []types.RulePriorityPair, value query.Value) error { 2585 if len(v) == 0 { 2586 return nil 2587 } 2588 array := value.Array("member") 2589 2590 for i := range v { 2591 av := array.Value() 2592 if err := awsAwsquery_serializeDocumentRulePriorityPair(&v[i], av); err != nil { 2593 return err 2594 } 2595 } 2596 return nil 2597} 2598 2599func awsAwsquery_serializeDocumentRulePriorityPair(v *types.RulePriorityPair, value query.Value) error { 2600 object := value.Object() 2601 _ = object 2602 2603 if v.Priority != nil { 2604 objectKey := object.Key("Priority") 2605 objectKey.Integer(*v.Priority) 2606 } 2607 2608 if v.RuleArn != nil { 2609 objectKey := object.Key("RuleArn") 2610 objectKey.String(*v.RuleArn) 2611 } 2612 2613 return nil 2614} 2615 2616func awsAwsquery_serializeDocumentSecurityGroups(v []string, value query.Value) error { 2617 if len(v) == 0 { 2618 return nil 2619 } 2620 array := value.Array("member") 2621 2622 for i := range v { 2623 av := array.Value() 2624 av.String(v[i]) 2625 } 2626 return nil 2627} 2628 2629func awsAwsquery_serializeDocumentSourceIpConditionConfig(v *types.SourceIpConditionConfig, value query.Value) error { 2630 object := value.Object() 2631 _ = object 2632 2633 if v.Values != nil { 2634 objectKey := object.Key("Values") 2635 if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil { 2636 return err 2637 } 2638 } 2639 2640 return nil 2641} 2642 2643func awsAwsquery_serializeDocumentSslPolicyNames(v []string, value query.Value) error { 2644 if len(v) == 0 { 2645 return nil 2646 } 2647 array := value.Array("member") 2648 2649 for i := range v { 2650 av := array.Value() 2651 av.String(v[i]) 2652 } 2653 return nil 2654} 2655 2656func awsAwsquery_serializeDocumentSubnetMapping(v *types.SubnetMapping, value query.Value) error { 2657 object := value.Object() 2658 _ = object 2659 2660 if v.AllocationId != nil { 2661 objectKey := object.Key("AllocationId") 2662 objectKey.String(*v.AllocationId) 2663 } 2664 2665 if v.IPv6Address != nil { 2666 objectKey := object.Key("IPv6Address") 2667 objectKey.String(*v.IPv6Address) 2668 } 2669 2670 if v.PrivateIPv4Address != nil { 2671 objectKey := object.Key("PrivateIPv4Address") 2672 objectKey.String(*v.PrivateIPv4Address) 2673 } 2674 2675 if v.SubnetId != nil { 2676 objectKey := object.Key("SubnetId") 2677 objectKey.String(*v.SubnetId) 2678 } 2679 2680 return nil 2681} 2682 2683func awsAwsquery_serializeDocumentSubnetMappings(v []types.SubnetMapping, value query.Value) error { 2684 if len(v) == 0 { 2685 return nil 2686 } 2687 array := value.Array("member") 2688 2689 for i := range v { 2690 av := array.Value() 2691 if err := awsAwsquery_serializeDocumentSubnetMapping(&v[i], av); err != nil { 2692 return err 2693 } 2694 } 2695 return nil 2696} 2697 2698func awsAwsquery_serializeDocumentSubnets(v []string, value query.Value) error { 2699 if len(v) == 0 { 2700 return nil 2701 } 2702 array := value.Array("member") 2703 2704 for i := range v { 2705 av := array.Value() 2706 av.String(v[i]) 2707 } 2708 return nil 2709} 2710 2711func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error { 2712 object := value.Object() 2713 _ = object 2714 2715 if v.Key != nil { 2716 objectKey := object.Key("Key") 2717 objectKey.String(*v.Key) 2718 } 2719 2720 if v.Value != nil { 2721 objectKey := object.Key("Value") 2722 objectKey.String(*v.Value) 2723 } 2724 2725 return nil 2726} 2727 2728func awsAwsquery_serializeDocumentTagKeys(v []string, value query.Value) error { 2729 if len(v) == 0 { 2730 return nil 2731 } 2732 array := value.Array("member") 2733 2734 for i := range v { 2735 av := array.Value() 2736 av.String(v[i]) 2737 } 2738 return nil 2739} 2740 2741func awsAwsquery_serializeDocumentTagList(v []types.Tag, value query.Value) error { 2742 if len(v) == 0 { 2743 return nil 2744 } 2745 array := value.Array("member") 2746 2747 for i := range v { 2748 av := array.Value() 2749 if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil { 2750 return err 2751 } 2752 } 2753 return nil 2754} 2755 2756func awsAwsquery_serializeDocumentTargetDescription(v *types.TargetDescription, value query.Value) error { 2757 object := value.Object() 2758 _ = object 2759 2760 if v.AvailabilityZone != nil { 2761 objectKey := object.Key("AvailabilityZone") 2762 objectKey.String(*v.AvailabilityZone) 2763 } 2764 2765 if v.Id != nil { 2766 objectKey := object.Key("Id") 2767 objectKey.String(*v.Id) 2768 } 2769 2770 if v.Port != nil { 2771 objectKey := object.Key("Port") 2772 objectKey.Integer(*v.Port) 2773 } 2774 2775 return nil 2776} 2777 2778func awsAwsquery_serializeDocumentTargetDescriptions(v []types.TargetDescription, value query.Value) error { 2779 if len(v) == 0 { 2780 return nil 2781 } 2782 array := value.Array("member") 2783 2784 for i := range v { 2785 av := array.Value() 2786 if err := awsAwsquery_serializeDocumentTargetDescription(&v[i], av); err != nil { 2787 return err 2788 } 2789 } 2790 return nil 2791} 2792 2793func awsAwsquery_serializeDocumentTargetGroupArns(v []string, value query.Value) error { 2794 if len(v) == 0 { 2795 return nil 2796 } 2797 array := value.Array("member") 2798 2799 for i := range v { 2800 av := array.Value() 2801 av.String(v[i]) 2802 } 2803 return nil 2804} 2805 2806func awsAwsquery_serializeDocumentTargetGroupAttribute(v *types.TargetGroupAttribute, value query.Value) error { 2807 object := value.Object() 2808 _ = object 2809 2810 if v.Key != nil { 2811 objectKey := object.Key("Key") 2812 objectKey.String(*v.Key) 2813 } 2814 2815 if v.Value != nil { 2816 objectKey := object.Key("Value") 2817 objectKey.String(*v.Value) 2818 } 2819 2820 return nil 2821} 2822 2823func awsAwsquery_serializeDocumentTargetGroupAttributes(v []types.TargetGroupAttribute, value query.Value) error { 2824 if len(v) == 0 { 2825 return nil 2826 } 2827 array := value.Array("member") 2828 2829 for i := range v { 2830 av := array.Value() 2831 if err := awsAwsquery_serializeDocumentTargetGroupAttribute(&v[i], av); err != nil { 2832 return err 2833 } 2834 } 2835 return nil 2836} 2837 2838func awsAwsquery_serializeDocumentTargetGroupList(v []types.TargetGroupTuple, value query.Value) error { 2839 if len(v) == 0 { 2840 return nil 2841 } 2842 array := value.Array("member") 2843 2844 for i := range v { 2845 av := array.Value() 2846 if err := awsAwsquery_serializeDocumentTargetGroupTuple(&v[i], av); err != nil { 2847 return err 2848 } 2849 } 2850 return nil 2851} 2852 2853func awsAwsquery_serializeDocumentTargetGroupNames(v []string, value query.Value) error { 2854 if len(v) == 0 { 2855 return nil 2856 } 2857 array := value.Array("member") 2858 2859 for i := range v { 2860 av := array.Value() 2861 av.String(v[i]) 2862 } 2863 return nil 2864} 2865 2866func awsAwsquery_serializeDocumentTargetGroupStickinessConfig(v *types.TargetGroupStickinessConfig, value query.Value) error { 2867 object := value.Object() 2868 _ = object 2869 2870 if v.DurationSeconds != nil { 2871 objectKey := object.Key("DurationSeconds") 2872 objectKey.Integer(*v.DurationSeconds) 2873 } 2874 2875 if v.Enabled != nil { 2876 objectKey := object.Key("Enabled") 2877 objectKey.Boolean(*v.Enabled) 2878 } 2879 2880 return nil 2881} 2882 2883func awsAwsquery_serializeDocumentTargetGroupTuple(v *types.TargetGroupTuple, value query.Value) error { 2884 object := value.Object() 2885 _ = object 2886 2887 if v.TargetGroupArn != nil { 2888 objectKey := object.Key("TargetGroupArn") 2889 objectKey.String(*v.TargetGroupArn) 2890 } 2891 2892 if v.Weight != nil { 2893 objectKey := object.Key("Weight") 2894 objectKey.Integer(*v.Weight) 2895 } 2896 2897 return nil 2898} 2899 2900func awsAwsquery_serializeOpDocumentAddListenerCertificatesInput(v *AddListenerCertificatesInput, value query.Value) error { 2901 object := value.Object() 2902 _ = object 2903 2904 if v.Certificates != nil { 2905 objectKey := object.Key("Certificates") 2906 if err := awsAwsquery_serializeDocumentCertificateList(v.Certificates, objectKey); err != nil { 2907 return err 2908 } 2909 } 2910 2911 if v.ListenerArn != nil { 2912 objectKey := object.Key("ListenerArn") 2913 objectKey.String(*v.ListenerArn) 2914 } 2915 2916 return nil 2917} 2918 2919func awsAwsquery_serializeOpDocumentAddTagsInput(v *AddTagsInput, value query.Value) error { 2920 object := value.Object() 2921 _ = object 2922 2923 if v.ResourceArns != nil { 2924 objectKey := object.Key("ResourceArns") 2925 if err := awsAwsquery_serializeDocumentResourceArns(v.ResourceArns, objectKey); err != nil { 2926 return err 2927 } 2928 } 2929 2930 if v.Tags != nil { 2931 objectKey := object.Key("Tags") 2932 if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil { 2933 return err 2934 } 2935 } 2936 2937 return nil 2938} 2939 2940func awsAwsquery_serializeOpDocumentCreateListenerInput(v *CreateListenerInput, value query.Value) error { 2941 object := value.Object() 2942 _ = object 2943 2944 if v.AlpnPolicy != nil { 2945 objectKey := object.Key("AlpnPolicy") 2946 if err := awsAwsquery_serializeDocumentAlpnPolicyName(v.AlpnPolicy, objectKey); err != nil { 2947 return err 2948 } 2949 } 2950 2951 if v.Certificates != nil { 2952 objectKey := object.Key("Certificates") 2953 if err := awsAwsquery_serializeDocumentCertificateList(v.Certificates, objectKey); err != nil { 2954 return err 2955 } 2956 } 2957 2958 if v.DefaultActions != nil { 2959 objectKey := object.Key("DefaultActions") 2960 if err := awsAwsquery_serializeDocumentActions(v.DefaultActions, objectKey); err != nil { 2961 return err 2962 } 2963 } 2964 2965 if v.LoadBalancerArn != nil { 2966 objectKey := object.Key("LoadBalancerArn") 2967 objectKey.String(*v.LoadBalancerArn) 2968 } 2969 2970 if v.Port != nil { 2971 objectKey := object.Key("Port") 2972 objectKey.Integer(*v.Port) 2973 } 2974 2975 if len(v.Protocol) > 0 { 2976 objectKey := object.Key("Protocol") 2977 objectKey.String(string(v.Protocol)) 2978 } 2979 2980 if v.SslPolicy != nil { 2981 objectKey := object.Key("SslPolicy") 2982 objectKey.String(*v.SslPolicy) 2983 } 2984 2985 if v.Tags != nil { 2986 objectKey := object.Key("Tags") 2987 if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil { 2988 return err 2989 } 2990 } 2991 2992 return nil 2993} 2994 2995func awsAwsquery_serializeOpDocumentCreateLoadBalancerInput(v *CreateLoadBalancerInput, value query.Value) error { 2996 object := value.Object() 2997 _ = object 2998 2999 if v.CustomerOwnedIpv4Pool != nil { 3000 objectKey := object.Key("CustomerOwnedIpv4Pool") 3001 objectKey.String(*v.CustomerOwnedIpv4Pool) 3002 } 3003 3004 if len(v.IpAddressType) > 0 { 3005 objectKey := object.Key("IpAddressType") 3006 objectKey.String(string(v.IpAddressType)) 3007 } 3008 3009 if v.Name != nil { 3010 objectKey := object.Key("Name") 3011 objectKey.String(*v.Name) 3012 } 3013 3014 if len(v.Scheme) > 0 { 3015 objectKey := object.Key("Scheme") 3016 objectKey.String(string(v.Scheme)) 3017 } 3018 3019 if v.SecurityGroups != nil { 3020 objectKey := object.Key("SecurityGroups") 3021 if err := awsAwsquery_serializeDocumentSecurityGroups(v.SecurityGroups, objectKey); err != nil { 3022 return err 3023 } 3024 } 3025 3026 if v.SubnetMappings != nil { 3027 objectKey := object.Key("SubnetMappings") 3028 if err := awsAwsquery_serializeDocumentSubnetMappings(v.SubnetMappings, objectKey); err != nil { 3029 return err 3030 } 3031 } 3032 3033 if v.Subnets != nil { 3034 objectKey := object.Key("Subnets") 3035 if err := awsAwsquery_serializeDocumentSubnets(v.Subnets, objectKey); err != nil { 3036 return err 3037 } 3038 } 3039 3040 if v.Tags != nil { 3041 objectKey := object.Key("Tags") 3042 if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil { 3043 return err 3044 } 3045 } 3046 3047 if len(v.Type) > 0 { 3048 objectKey := object.Key("Type") 3049 objectKey.String(string(v.Type)) 3050 } 3051 3052 return nil 3053} 3054 3055func awsAwsquery_serializeOpDocumentCreateRuleInput(v *CreateRuleInput, value query.Value) error { 3056 object := value.Object() 3057 _ = object 3058 3059 if v.Actions != nil { 3060 objectKey := object.Key("Actions") 3061 if err := awsAwsquery_serializeDocumentActions(v.Actions, objectKey); err != nil { 3062 return err 3063 } 3064 } 3065 3066 if v.Conditions != nil { 3067 objectKey := object.Key("Conditions") 3068 if err := awsAwsquery_serializeDocumentRuleConditionList(v.Conditions, objectKey); err != nil { 3069 return err 3070 } 3071 } 3072 3073 if v.ListenerArn != nil { 3074 objectKey := object.Key("ListenerArn") 3075 objectKey.String(*v.ListenerArn) 3076 } 3077 3078 if v.Priority != nil { 3079 objectKey := object.Key("Priority") 3080 objectKey.Integer(*v.Priority) 3081 } 3082 3083 if v.Tags != nil { 3084 objectKey := object.Key("Tags") 3085 if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil { 3086 return err 3087 } 3088 } 3089 3090 return nil 3091} 3092 3093func awsAwsquery_serializeOpDocumentCreateTargetGroupInput(v *CreateTargetGroupInput, value query.Value) error { 3094 object := value.Object() 3095 _ = object 3096 3097 if v.HealthCheckEnabled != nil { 3098 objectKey := object.Key("HealthCheckEnabled") 3099 objectKey.Boolean(*v.HealthCheckEnabled) 3100 } 3101 3102 if v.HealthCheckIntervalSeconds != nil { 3103 objectKey := object.Key("HealthCheckIntervalSeconds") 3104 objectKey.Integer(*v.HealthCheckIntervalSeconds) 3105 } 3106 3107 if v.HealthCheckPath != nil { 3108 objectKey := object.Key("HealthCheckPath") 3109 objectKey.String(*v.HealthCheckPath) 3110 } 3111 3112 if v.HealthCheckPort != nil { 3113 objectKey := object.Key("HealthCheckPort") 3114 objectKey.String(*v.HealthCheckPort) 3115 } 3116 3117 if len(v.HealthCheckProtocol) > 0 { 3118 objectKey := object.Key("HealthCheckProtocol") 3119 objectKey.String(string(v.HealthCheckProtocol)) 3120 } 3121 3122 if v.HealthCheckTimeoutSeconds != nil { 3123 objectKey := object.Key("HealthCheckTimeoutSeconds") 3124 objectKey.Integer(*v.HealthCheckTimeoutSeconds) 3125 } 3126 3127 if v.HealthyThresholdCount != nil { 3128 objectKey := object.Key("HealthyThresholdCount") 3129 objectKey.Integer(*v.HealthyThresholdCount) 3130 } 3131 3132 if v.Matcher != nil { 3133 objectKey := object.Key("Matcher") 3134 if err := awsAwsquery_serializeDocumentMatcher(v.Matcher, objectKey); err != nil { 3135 return err 3136 } 3137 } 3138 3139 if v.Name != nil { 3140 objectKey := object.Key("Name") 3141 objectKey.String(*v.Name) 3142 } 3143 3144 if v.Port != nil { 3145 objectKey := object.Key("Port") 3146 objectKey.Integer(*v.Port) 3147 } 3148 3149 if len(v.Protocol) > 0 { 3150 objectKey := object.Key("Protocol") 3151 objectKey.String(string(v.Protocol)) 3152 } 3153 3154 if v.ProtocolVersion != nil { 3155 objectKey := object.Key("ProtocolVersion") 3156 objectKey.String(*v.ProtocolVersion) 3157 } 3158 3159 if v.Tags != nil { 3160 objectKey := object.Key("Tags") 3161 if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil { 3162 return err 3163 } 3164 } 3165 3166 if len(v.TargetType) > 0 { 3167 objectKey := object.Key("TargetType") 3168 objectKey.String(string(v.TargetType)) 3169 } 3170 3171 if v.UnhealthyThresholdCount != nil { 3172 objectKey := object.Key("UnhealthyThresholdCount") 3173 objectKey.Integer(*v.UnhealthyThresholdCount) 3174 } 3175 3176 if v.VpcId != nil { 3177 objectKey := object.Key("VpcId") 3178 objectKey.String(*v.VpcId) 3179 } 3180 3181 return nil 3182} 3183 3184func awsAwsquery_serializeOpDocumentDeleteListenerInput(v *DeleteListenerInput, value query.Value) error { 3185 object := value.Object() 3186 _ = object 3187 3188 if v.ListenerArn != nil { 3189 objectKey := object.Key("ListenerArn") 3190 objectKey.String(*v.ListenerArn) 3191 } 3192 3193 return nil 3194} 3195 3196func awsAwsquery_serializeOpDocumentDeleteLoadBalancerInput(v *DeleteLoadBalancerInput, value query.Value) error { 3197 object := value.Object() 3198 _ = object 3199 3200 if v.LoadBalancerArn != nil { 3201 objectKey := object.Key("LoadBalancerArn") 3202 objectKey.String(*v.LoadBalancerArn) 3203 } 3204 3205 return nil 3206} 3207 3208func awsAwsquery_serializeOpDocumentDeleteRuleInput(v *DeleteRuleInput, value query.Value) error { 3209 object := value.Object() 3210 _ = object 3211 3212 if v.RuleArn != nil { 3213 objectKey := object.Key("RuleArn") 3214 objectKey.String(*v.RuleArn) 3215 } 3216 3217 return nil 3218} 3219 3220func awsAwsquery_serializeOpDocumentDeleteTargetGroupInput(v *DeleteTargetGroupInput, value query.Value) error { 3221 object := value.Object() 3222 _ = object 3223 3224 if v.TargetGroupArn != nil { 3225 objectKey := object.Key("TargetGroupArn") 3226 objectKey.String(*v.TargetGroupArn) 3227 } 3228 3229 return nil 3230} 3231 3232func awsAwsquery_serializeOpDocumentDeregisterTargetsInput(v *DeregisterTargetsInput, value query.Value) error { 3233 object := value.Object() 3234 _ = object 3235 3236 if v.TargetGroupArn != nil { 3237 objectKey := object.Key("TargetGroupArn") 3238 objectKey.String(*v.TargetGroupArn) 3239 } 3240 3241 if v.Targets != nil { 3242 objectKey := object.Key("Targets") 3243 if err := awsAwsquery_serializeDocumentTargetDescriptions(v.Targets, objectKey); err != nil { 3244 return err 3245 } 3246 } 3247 3248 return nil 3249} 3250 3251func awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(v *DescribeAccountLimitsInput, value query.Value) error { 3252 object := value.Object() 3253 _ = object 3254 3255 if v.Marker != nil { 3256 objectKey := object.Key("Marker") 3257 objectKey.String(*v.Marker) 3258 } 3259 3260 if v.PageSize != nil { 3261 objectKey := object.Key("PageSize") 3262 objectKey.Integer(*v.PageSize) 3263 } 3264 3265 return nil 3266} 3267 3268func awsAwsquery_serializeOpDocumentDescribeListenerCertificatesInput(v *DescribeListenerCertificatesInput, value query.Value) error { 3269 object := value.Object() 3270 _ = object 3271 3272 if v.ListenerArn != nil { 3273 objectKey := object.Key("ListenerArn") 3274 objectKey.String(*v.ListenerArn) 3275 } 3276 3277 if v.Marker != nil { 3278 objectKey := object.Key("Marker") 3279 objectKey.String(*v.Marker) 3280 } 3281 3282 if v.PageSize != nil { 3283 objectKey := object.Key("PageSize") 3284 objectKey.Integer(*v.PageSize) 3285 } 3286 3287 return nil 3288} 3289 3290func awsAwsquery_serializeOpDocumentDescribeListenersInput(v *DescribeListenersInput, value query.Value) error { 3291 object := value.Object() 3292 _ = object 3293 3294 if v.ListenerArns != nil { 3295 objectKey := object.Key("ListenerArns") 3296 if err := awsAwsquery_serializeDocumentListenerArns(v.ListenerArns, objectKey); err != nil { 3297 return err 3298 } 3299 } 3300 3301 if v.LoadBalancerArn != nil { 3302 objectKey := object.Key("LoadBalancerArn") 3303 objectKey.String(*v.LoadBalancerArn) 3304 } 3305 3306 if v.Marker != nil { 3307 objectKey := object.Key("Marker") 3308 objectKey.String(*v.Marker) 3309 } 3310 3311 if v.PageSize != nil { 3312 objectKey := object.Key("PageSize") 3313 objectKey.Integer(*v.PageSize) 3314 } 3315 3316 return nil 3317} 3318 3319func awsAwsquery_serializeOpDocumentDescribeLoadBalancerAttributesInput(v *DescribeLoadBalancerAttributesInput, value query.Value) error { 3320 object := value.Object() 3321 _ = object 3322 3323 if v.LoadBalancerArn != nil { 3324 objectKey := object.Key("LoadBalancerArn") 3325 objectKey.String(*v.LoadBalancerArn) 3326 } 3327 3328 return nil 3329} 3330 3331func awsAwsquery_serializeOpDocumentDescribeLoadBalancersInput(v *DescribeLoadBalancersInput, value query.Value) error { 3332 object := value.Object() 3333 _ = object 3334 3335 if v.LoadBalancerArns != nil { 3336 objectKey := object.Key("LoadBalancerArns") 3337 if err := awsAwsquery_serializeDocumentLoadBalancerArns(v.LoadBalancerArns, objectKey); err != nil { 3338 return err 3339 } 3340 } 3341 3342 if v.Marker != nil { 3343 objectKey := object.Key("Marker") 3344 objectKey.String(*v.Marker) 3345 } 3346 3347 if v.Names != nil { 3348 objectKey := object.Key("Names") 3349 if err := awsAwsquery_serializeDocumentLoadBalancerNames(v.Names, objectKey); err != nil { 3350 return err 3351 } 3352 } 3353 3354 if v.PageSize != nil { 3355 objectKey := object.Key("PageSize") 3356 objectKey.Integer(*v.PageSize) 3357 } 3358 3359 return nil 3360} 3361 3362func awsAwsquery_serializeOpDocumentDescribeRulesInput(v *DescribeRulesInput, value query.Value) error { 3363 object := value.Object() 3364 _ = object 3365 3366 if v.ListenerArn != nil { 3367 objectKey := object.Key("ListenerArn") 3368 objectKey.String(*v.ListenerArn) 3369 } 3370 3371 if v.Marker != nil { 3372 objectKey := object.Key("Marker") 3373 objectKey.String(*v.Marker) 3374 } 3375 3376 if v.PageSize != nil { 3377 objectKey := object.Key("PageSize") 3378 objectKey.Integer(*v.PageSize) 3379 } 3380 3381 if v.RuleArns != nil { 3382 objectKey := object.Key("RuleArns") 3383 if err := awsAwsquery_serializeDocumentRuleArns(v.RuleArns, objectKey); err != nil { 3384 return err 3385 } 3386 } 3387 3388 return nil 3389} 3390 3391func awsAwsquery_serializeOpDocumentDescribeSSLPoliciesInput(v *DescribeSSLPoliciesInput, value query.Value) error { 3392 object := value.Object() 3393 _ = object 3394 3395 if v.Marker != nil { 3396 objectKey := object.Key("Marker") 3397 objectKey.String(*v.Marker) 3398 } 3399 3400 if v.Names != nil { 3401 objectKey := object.Key("Names") 3402 if err := awsAwsquery_serializeDocumentSslPolicyNames(v.Names, objectKey); err != nil { 3403 return err 3404 } 3405 } 3406 3407 if v.PageSize != nil { 3408 objectKey := object.Key("PageSize") 3409 objectKey.Integer(*v.PageSize) 3410 } 3411 3412 return nil 3413} 3414 3415func awsAwsquery_serializeOpDocumentDescribeTagsInput(v *DescribeTagsInput, value query.Value) error { 3416 object := value.Object() 3417 _ = object 3418 3419 if v.ResourceArns != nil { 3420 objectKey := object.Key("ResourceArns") 3421 if err := awsAwsquery_serializeDocumentResourceArns(v.ResourceArns, objectKey); err != nil { 3422 return err 3423 } 3424 } 3425 3426 return nil 3427} 3428 3429func awsAwsquery_serializeOpDocumentDescribeTargetGroupAttributesInput(v *DescribeTargetGroupAttributesInput, value query.Value) error { 3430 object := value.Object() 3431 _ = object 3432 3433 if v.TargetGroupArn != nil { 3434 objectKey := object.Key("TargetGroupArn") 3435 objectKey.String(*v.TargetGroupArn) 3436 } 3437 3438 return nil 3439} 3440 3441func awsAwsquery_serializeOpDocumentDescribeTargetGroupsInput(v *DescribeTargetGroupsInput, value query.Value) error { 3442 object := value.Object() 3443 _ = object 3444 3445 if v.LoadBalancerArn != nil { 3446 objectKey := object.Key("LoadBalancerArn") 3447 objectKey.String(*v.LoadBalancerArn) 3448 } 3449 3450 if v.Marker != nil { 3451 objectKey := object.Key("Marker") 3452 objectKey.String(*v.Marker) 3453 } 3454 3455 if v.Names != nil { 3456 objectKey := object.Key("Names") 3457 if err := awsAwsquery_serializeDocumentTargetGroupNames(v.Names, objectKey); err != nil { 3458 return err 3459 } 3460 } 3461 3462 if v.PageSize != nil { 3463 objectKey := object.Key("PageSize") 3464 objectKey.Integer(*v.PageSize) 3465 } 3466 3467 if v.TargetGroupArns != nil { 3468 objectKey := object.Key("TargetGroupArns") 3469 if err := awsAwsquery_serializeDocumentTargetGroupArns(v.TargetGroupArns, objectKey); err != nil { 3470 return err 3471 } 3472 } 3473 3474 return nil 3475} 3476 3477func awsAwsquery_serializeOpDocumentDescribeTargetHealthInput(v *DescribeTargetHealthInput, value query.Value) error { 3478 object := value.Object() 3479 _ = object 3480 3481 if v.TargetGroupArn != nil { 3482 objectKey := object.Key("TargetGroupArn") 3483 objectKey.String(*v.TargetGroupArn) 3484 } 3485 3486 if v.Targets != nil { 3487 objectKey := object.Key("Targets") 3488 if err := awsAwsquery_serializeDocumentTargetDescriptions(v.Targets, objectKey); err != nil { 3489 return err 3490 } 3491 } 3492 3493 return nil 3494} 3495 3496func awsAwsquery_serializeOpDocumentModifyListenerInput(v *ModifyListenerInput, value query.Value) error { 3497 object := value.Object() 3498 _ = object 3499 3500 if v.AlpnPolicy != nil { 3501 objectKey := object.Key("AlpnPolicy") 3502 if err := awsAwsquery_serializeDocumentAlpnPolicyName(v.AlpnPolicy, objectKey); err != nil { 3503 return err 3504 } 3505 } 3506 3507 if v.Certificates != nil { 3508 objectKey := object.Key("Certificates") 3509 if err := awsAwsquery_serializeDocumentCertificateList(v.Certificates, objectKey); err != nil { 3510 return err 3511 } 3512 } 3513 3514 if v.DefaultActions != nil { 3515 objectKey := object.Key("DefaultActions") 3516 if err := awsAwsquery_serializeDocumentActions(v.DefaultActions, objectKey); err != nil { 3517 return err 3518 } 3519 } 3520 3521 if v.ListenerArn != nil { 3522 objectKey := object.Key("ListenerArn") 3523 objectKey.String(*v.ListenerArn) 3524 } 3525 3526 if v.Port != nil { 3527 objectKey := object.Key("Port") 3528 objectKey.Integer(*v.Port) 3529 } 3530 3531 if len(v.Protocol) > 0 { 3532 objectKey := object.Key("Protocol") 3533 objectKey.String(string(v.Protocol)) 3534 } 3535 3536 if v.SslPolicy != nil { 3537 objectKey := object.Key("SslPolicy") 3538 objectKey.String(*v.SslPolicy) 3539 } 3540 3541 return nil 3542} 3543 3544func awsAwsquery_serializeOpDocumentModifyLoadBalancerAttributesInput(v *ModifyLoadBalancerAttributesInput, value query.Value) error { 3545 object := value.Object() 3546 _ = object 3547 3548 if v.Attributes != nil { 3549 objectKey := object.Key("Attributes") 3550 if err := awsAwsquery_serializeDocumentLoadBalancerAttributes(v.Attributes, objectKey); err != nil { 3551 return err 3552 } 3553 } 3554 3555 if v.LoadBalancerArn != nil { 3556 objectKey := object.Key("LoadBalancerArn") 3557 objectKey.String(*v.LoadBalancerArn) 3558 } 3559 3560 return nil 3561} 3562 3563func awsAwsquery_serializeOpDocumentModifyRuleInput(v *ModifyRuleInput, value query.Value) error { 3564 object := value.Object() 3565 _ = object 3566 3567 if v.Actions != nil { 3568 objectKey := object.Key("Actions") 3569 if err := awsAwsquery_serializeDocumentActions(v.Actions, objectKey); err != nil { 3570 return err 3571 } 3572 } 3573 3574 if v.Conditions != nil { 3575 objectKey := object.Key("Conditions") 3576 if err := awsAwsquery_serializeDocumentRuleConditionList(v.Conditions, objectKey); err != nil { 3577 return err 3578 } 3579 } 3580 3581 if v.RuleArn != nil { 3582 objectKey := object.Key("RuleArn") 3583 objectKey.String(*v.RuleArn) 3584 } 3585 3586 return nil 3587} 3588 3589func awsAwsquery_serializeOpDocumentModifyTargetGroupAttributesInput(v *ModifyTargetGroupAttributesInput, value query.Value) error { 3590 object := value.Object() 3591 _ = object 3592 3593 if v.Attributes != nil { 3594 objectKey := object.Key("Attributes") 3595 if err := awsAwsquery_serializeDocumentTargetGroupAttributes(v.Attributes, objectKey); err != nil { 3596 return err 3597 } 3598 } 3599 3600 if v.TargetGroupArn != nil { 3601 objectKey := object.Key("TargetGroupArn") 3602 objectKey.String(*v.TargetGroupArn) 3603 } 3604 3605 return nil 3606} 3607 3608func awsAwsquery_serializeOpDocumentModifyTargetGroupInput(v *ModifyTargetGroupInput, value query.Value) error { 3609 object := value.Object() 3610 _ = object 3611 3612 if v.HealthCheckEnabled != nil { 3613 objectKey := object.Key("HealthCheckEnabled") 3614 objectKey.Boolean(*v.HealthCheckEnabled) 3615 } 3616 3617 if v.HealthCheckIntervalSeconds != nil { 3618 objectKey := object.Key("HealthCheckIntervalSeconds") 3619 objectKey.Integer(*v.HealthCheckIntervalSeconds) 3620 } 3621 3622 if v.HealthCheckPath != nil { 3623 objectKey := object.Key("HealthCheckPath") 3624 objectKey.String(*v.HealthCheckPath) 3625 } 3626 3627 if v.HealthCheckPort != nil { 3628 objectKey := object.Key("HealthCheckPort") 3629 objectKey.String(*v.HealthCheckPort) 3630 } 3631 3632 if len(v.HealthCheckProtocol) > 0 { 3633 objectKey := object.Key("HealthCheckProtocol") 3634 objectKey.String(string(v.HealthCheckProtocol)) 3635 } 3636 3637 if v.HealthCheckTimeoutSeconds != nil { 3638 objectKey := object.Key("HealthCheckTimeoutSeconds") 3639 objectKey.Integer(*v.HealthCheckTimeoutSeconds) 3640 } 3641 3642 if v.HealthyThresholdCount != nil { 3643 objectKey := object.Key("HealthyThresholdCount") 3644 objectKey.Integer(*v.HealthyThresholdCount) 3645 } 3646 3647 if v.Matcher != nil { 3648 objectKey := object.Key("Matcher") 3649 if err := awsAwsquery_serializeDocumentMatcher(v.Matcher, objectKey); err != nil { 3650 return err 3651 } 3652 } 3653 3654 if v.TargetGroupArn != nil { 3655 objectKey := object.Key("TargetGroupArn") 3656 objectKey.String(*v.TargetGroupArn) 3657 } 3658 3659 if v.UnhealthyThresholdCount != nil { 3660 objectKey := object.Key("UnhealthyThresholdCount") 3661 objectKey.Integer(*v.UnhealthyThresholdCount) 3662 } 3663 3664 return nil 3665} 3666 3667func awsAwsquery_serializeOpDocumentRegisterTargetsInput(v *RegisterTargetsInput, value query.Value) error { 3668 object := value.Object() 3669 _ = object 3670 3671 if v.TargetGroupArn != nil { 3672 objectKey := object.Key("TargetGroupArn") 3673 objectKey.String(*v.TargetGroupArn) 3674 } 3675 3676 if v.Targets != nil { 3677 objectKey := object.Key("Targets") 3678 if err := awsAwsquery_serializeDocumentTargetDescriptions(v.Targets, objectKey); err != nil { 3679 return err 3680 } 3681 } 3682 3683 return nil 3684} 3685 3686func awsAwsquery_serializeOpDocumentRemoveListenerCertificatesInput(v *RemoveListenerCertificatesInput, value query.Value) error { 3687 object := value.Object() 3688 _ = object 3689 3690 if v.Certificates != nil { 3691 objectKey := object.Key("Certificates") 3692 if err := awsAwsquery_serializeDocumentCertificateList(v.Certificates, objectKey); err != nil { 3693 return err 3694 } 3695 } 3696 3697 if v.ListenerArn != nil { 3698 objectKey := object.Key("ListenerArn") 3699 objectKey.String(*v.ListenerArn) 3700 } 3701 3702 return nil 3703} 3704 3705func awsAwsquery_serializeOpDocumentRemoveTagsInput(v *RemoveTagsInput, value query.Value) error { 3706 object := value.Object() 3707 _ = object 3708 3709 if v.ResourceArns != nil { 3710 objectKey := object.Key("ResourceArns") 3711 if err := awsAwsquery_serializeDocumentResourceArns(v.ResourceArns, objectKey); err != nil { 3712 return err 3713 } 3714 } 3715 3716 if v.TagKeys != nil { 3717 objectKey := object.Key("TagKeys") 3718 if err := awsAwsquery_serializeDocumentTagKeys(v.TagKeys, objectKey); err != nil { 3719 return err 3720 } 3721 } 3722 3723 return nil 3724} 3725 3726func awsAwsquery_serializeOpDocumentSetIpAddressTypeInput(v *SetIpAddressTypeInput, value query.Value) error { 3727 object := value.Object() 3728 _ = object 3729 3730 if len(v.IpAddressType) > 0 { 3731 objectKey := object.Key("IpAddressType") 3732 objectKey.String(string(v.IpAddressType)) 3733 } 3734 3735 if v.LoadBalancerArn != nil { 3736 objectKey := object.Key("LoadBalancerArn") 3737 objectKey.String(*v.LoadBalancerArn) 3738 } 3739 3740 return nil 3741} 3742 3743func awsAwsquery_serializeOpDocumentSetRulePrioritiesInput(v *SetRulePrioritiesInput, value query.Value) error { 3744 object := value.Object() 3745 _ = object 3746 3747 if v.RulePriorities != nil { 3748 objectKey := object.Key("RulePriorities") 3749 if err := awsAwsquery_serializeDocumentRulePriorityList(v.RulePriorities, objectKey); err != nil { 3750 return err 3751 } 3752 } 3753 3754 return nil 3755} 3756 3757func awsAwsquery_serializeOpDocumentSetSecurityGroupsInput(v *SetSecurityGroupsInput, value query.Value) error { 3758 object := value.Object() 3759 _ = object 3760 3761 if v.LoadBalancerArn != nil { 3762 objectKey := object.Key("LoadBalancerArn") 3763 objectKey.String(*v.LoadBalancerArn) 3764 } 3765 3766 if v.SecurityGroups != nil { 3767 objectKey := object.Key("SecurityGroups") 3768 if err := awsAwsquery_serializeDocumentSecurityGroups(v.SecurityGroups, objectKey); err != nil { 3769 return err 3770 } 3771 } 3772 3773 return nil 3774} 3775 3776func awsAwsquery_serializeOpDocumentSetSubnetsInput(v *SetSubnetsInput, value query.Value) error { 3777 object := value.Object() 3778 _ = object 3779 3780 if len(v.IpAddressType) > 0 { 3781 objectKey := object.Key("IpAddressType") 3782 objectKey.String(string(v.IpAddressType)) 3783 } 3784 3785 if v.LoadBalancerArn != nil { 3786 objectKey := object.Key("LoadBalancerArn") 3787 objectKey.String(*v.LoadBalancerArn) 3788 } 3789 3790 if v.SubnetMappings != nil { 3791 objectKey := object.Key("SubnetMappings") 3792 if err := awsAwsquery_serializeDocumentSubnetMappings(v.SubnetMappings, objectKey); err != nil { 3793 return err 3794 } 3795 } 3796 3797 if v.Subnets != nil { 3798 objectKey := object.Key("Subnets") 3799 if err := awsAwsquery_serializeDocumentSubnets(v.Subnets, objectKey); err != nil { 3800 return err 3801 } 3802 } 3803 3804 return nil 3805} 3806