1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package cloudformation 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/cloudformation/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_serializeOpActivateType struct { 19} 20 21func (*awsAwsquery_serializeOpActivateType) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsAwsquery_serializeOpActivateType) 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.(*ActivateTypeInput) 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("ActivateType") 51 body.Key("Version").String("2010-05-15") 52 53 if err := awsAwsquery_serializeOpDocumentActivateTypeInput(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_serializeOpBatchDescribeTypeConfigurations struct { 75} 76 77func (*awsAwsquery_serializeOpBatchDescribeTypeConfigurations) ID() string { 78 return "OperationSerializer" 79} 80 81func (m *awsAwsquery_serializeOpBatchDescribeTypeConfigurations) 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.(*BatchDescribeTypeConfigurationsInput) 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("BatchDescribeTypeConfigurations") 107 body.Key("Version").String("2010-05-15") 108 109 if err := awsAwsquery_serializeOpDocumentBatchDescribeTypeConfigurationsInput(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_serializeOpCancelUpdateStack struct { 131} 132 133func (*awsAwsquery_serializeOpCancelUpdateStack) ID() string { 134 return "OperationSerializer" 135} 136 137func (m *awsAwsquery_serializeOpCancelUpdateStack) 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.(*CancelUpdateStackInput) 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("CancelUpdateStack") 163 body.Key("Version").String("2010-05-15") 164 165 if err := awsAwsquery_serializeOpDocumentCancelUpdateStackInput(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_serializeOpContinueUpdateRollback struct { 187} 188 189func (*awsAwsquery_serializeOpContinueUpdateRollback) ID() string { 190 return "OperationSerializer" 191} 192 193func (m *awsAwsquery_serializeOpContinueUpdateRollback) 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.(*ContinueUpdateRollbackInput) 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("ContinueUpdateRollback") 219 body.Key("Version").String("2010-05-15") 220 221 if err := awsAwsquery_serializeOpDocumentContinueUpdateRollbackInput(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_serializeOpCreateChangeSet struct { 243} 244 245func (*awsAwsquery_serializeOpCreateChangeSet) ID() string { 246 return "OperationSerializer" 247} 248 249func (m *awsAwsquery_serializeOpCreateChangeSet) 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.(*CreateChangeSetInput) 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("CreateChangeSet") 275 body.Key("Version").String("2010-05-15") 276 277 if err := awsAwsquery_serializeOpDocumentCreateChangeSetInput(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_serializeOpCreateStack struct { 299} 300 301func (*awsAwsquery_serializeOpCreateStack) ID() string { 302 return "OperationSerializer" 303} 304 305func (m *awsAwsquery_serializeOpCreateStack) 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.(*CreateStackInput) 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("CreateStack") 331 body.Key("Version").String("2010-05-15") 332 333 if err := awsAwsquery_serializeOpDocumentCreateStackInput(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_serializeOpCreateStackInstances struct { 355} 356 357func (*awsAwsquery_serializeOpCreateStackInstances) ID() string { 358 return "OperationSerializer" 359} 360 361func (m *awsAwsquery_serializeOpCreateStackInstances) 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.(*CreateStackInstancesInput) 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("CreateStackInstances") 387 body.Key("Version").String("2010-05-15") 388 389 if err := awsAwsquery_serializeOpDocumentCreateStackInstancesInput(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_serializeOpCreateStackSet struct { 411} 412 413func (*awsAwsquery_serializeOpCreateStackSet) ID() string { 414 return "OperationSerializer" 415} 416 417func (m *awsAwsquery_serializeOpCreateStackSet) 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.(*CreateStackSetInput) 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("CreateStackSet") 443 body.Key("Version").String("2010-05-15") 444 445 if err := awsAwsquery_serializeOpDocumentCreateStackSetInput(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_serializeOpDeactivateType struct { 467} 468 469func (*awsAwsquery_serializeOpDeactivateType) ID() string { 470 return "OperationSerializer" 471} 472 473func (m *awsAwsquery_serializeOpDeactivateType) 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.(*DeactivateTypeInput) 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("DeactivateType") 499 body.Key("Version").String("2010-05-15") 500 501 if err := awsAwsquery_serializeOpDocumentDeactivateTypeInput(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_serializeOpDeleteChangeSet struct { 523} 524 525func (*awsAwsquery_serializeOpDeleteChangeSet) ID() string { 526 return "OperationSerializer" 527} 528 529func (m *awsAwsquery_serializeOpDeleteChangeSet) 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.(*DeleteChangeSetInput) 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("DeleteChangeSet") 555 body.Key("Version").String("2010-05-15") 556 557 if err := awsAwsquery_serializeOpDocumentDeleteChangeSetInput(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_serializeOpDeleteStack struct { 579} 580 581func (*awsAwsquery_serializeOpDeleteStack) ID() string { 582 return "OperationSerializer" 583} 584 585func (m *awsAwsquery_serializeOpDeleteStack) 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.(*DeleteStackInput) 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("DeleteStack") 611 body.Key("Version").String("2010-05-15") 612 613 if err := awsAwsquery_serializeOpDocumentDeleteStackInput(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_serializeOpDeleteStackInstances struct { 635} 636 637func (*awsAwsquery_serializeOpDeleteStackInstances) ID() string { 638 return "OperationSerializer" 639} 640 641func (m *awsAwsquery_serializeOpDeleteStackInstances) 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.(*DeleteStackInstancesInput) 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("DeleteStackInstances") 667 body.Key("Version").String("2010-05-15") 668 669 if err := awsAwsquery_serializeOpDocumentDeleteStackInstancesInput(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_serializeOpDeleteStackSet struct { 691} 692 693func (*awsAwsquery_serializeOpDeleteStackSet) ID() string { 694 return "OperationSerializer" 695} 696 697func (m *awsAwsquery_serializeOpDeleteStackSet) 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.(*DeleteStackSetInput) 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("DeleteStackSet") 723 body.Key("Version").String("2010-05-15") 724 725 if err := awsAwsquery_serializeOpDocumentDeleteStackSetInput(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_serializeOpDeregisterType struct { 747} 748 749func (*awsAwsquery_serializeOpDeregisterType) ID() string { 750 return "OperationSerializer" 751} 752 753func (m *awsAwsquery_serializeOpDeregisterType) 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.(*DeregisterTypeInput) 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("DeregisterType") 779 body.Key("Version").String("2010-05-15") 780 781 if err := awsAwsquery_serializeOpDocumentDeregisterTypeInput(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_serializeOpDescribeAccountLimits struct { 803} 804 805func (*awsAwsquery_serializeOpDescribeAccountLimits) ID() string { 806 return "OperationSerializer" 807} 808 809func (m *awsAwsquery_serializeOpDescribeAccountLimits) 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.(*DescribeAccountLimitsInput) 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("DescribeAccountLimits") 835 body.Key("Version").String("2010-05-15") 836 837 if err := awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(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_serializeOpDescribeChangeSet struct { 859} 860 861func (*awsAwsquery_serializeOpDescribeChangeSet) ID() string { 862 return "OperationSerializer" 863} 864 865func (m *awsAwsquery_serializeOpDescribeChangeSet) 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.(*DescribeChangeSetInput) 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("DescribeChangeSet") 891 body.Key("Version").String("2010-05-15") 892 893 if err := awsAwsquery_serializeOpDocumentDescribeChangeSetInput(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_serializeOpDescribePublisher struct { 915} 916 917func (*awsAwsquery_serializeOpDescribePublisher) ID() string { 918 return "OperationSerializer" 919} 920 921func (m *awsAwsquery_serializeOpDescribePublisher) 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.(*DescribePublisherInput) 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("DescribePublisher") 947 body.Key("Version").String("2010-05-15") 948 949 if err := awsAwsquery_serializeOpDocumentDescribePublisherInput(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_serializeOpDescribeStackDriftDetectionStatus struct { 971} 972 973func (*awsAwsquery_serializeOpDescribeStackDriftDetectionStatus) ID() string { 974 return "OperationSerializer" 975} 976 977func (m *awsAwsquery_serializeOpDescribeStackDriftDetectionStatus) 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.(*DescribeStackDriftDetectionStatusInput) 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("DescribeStackDriftDetectionStatus") 1003 body.Key("Version").String("2010-05-15") 1004 1005 if err := awsAwsquery_serializeOpDocumentDescribeStackDriftDetectionStatusInput(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_serializeOpDescribeStackEvents struct { 1027} 1028 1029func (*awsAwsquery_serializeOpDescribeStackEvents) ID() string { 1030 return "OperationSerializer" 1031} 1032 1033func (m *awsAwsquery_serializeOpDescribeStackEvents) 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.(*DescribeStackEventsInput) 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("DescribeStackEvents") 1059 body.Key("Version").String("2010-05-15") 1060 1061 if err := awsAwsquery_serializeOpDocumentDescribeStackEventsInput(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_serializeOpDescribeStackInstance struct { 1083} 1084 1085func (*awsAwsquery_serializeOpDescribeStackInstance) ID() string { 1086 return "OperationSerializer" 1087} 1088 1089func (m *awsAwsquery_serializeOpDescribeStackInstance) 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.(*DescribeStackInstanceInput) 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("DescribeStackInstance") 1115 body.Key("Version").String("2010-05-15") 1116 1117 if err := awsAwsquery_serializeOpDocumentDescribeStackInstanceInput(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_serializeOpDescribeStackResource struct { 1139} 1140 1141func (*awsAwsquery_serializeOpDescribeStackResource) ID() string { 1142 return "OperationSerializer" 1143} 1144 1145func (m *awsAwsquery_serializeOpDescribeStackResource) 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.(*DescribeStackResourceInput) 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("DescribeStackResource") 1171 body.Key("Version").String("2010-05-15") 1172 1173 if err := awsAwsquery_serializeOpDocumentDescribeStackResourceInput(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_serializeOpDescribeStackResourceDrifts struct { 1195} 1196 1197func (*awsAwsquery_serializeOpDescribeStackResourceDrifts) ID() string { 1198 return "OperationSerializer" 1199} 1200 1201func (m *awsAwsquery_serializeOpDescribeStackResourceDrifts) 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.(*DescribeStackResourceDriftsInput) 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("DescribeStackResourceDrifts") 1227 body.Key("Version").String("2010-05-15") 1228 1229 if err := awsAwsquery_serializeOpDocumentDescribeStackResourceDriftsInput(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_serializeOpDescribeStackResources struct { 1251} 1252 1253func (*awsAwsquery_serializeOpDescribeStackResources) ID() string { 1254 return "OperationSerializer" 1255} 1256 1257func (m *awsAwsquery_serializeOpDescribeStackResources) 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.(*DescribeStackResourcesInput) 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("DescribeStackResources") 1283 body.Key("Version").String("2010-05-15") 1284 1285 if err := awsAwsquery_serializeOpDocumentDescribeStackResourcesInput(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_serializeOpDescribeStacks struct { 1307} 1308 1309func (*awsAwsquery_serializeOpDescribeStacks) ID() string { 1310 return "OperationSerializer" 1311} 1312 1313func (m *awsAwsquery_serializeOpDescribeStacks) 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.(*DescribeStacksInput) 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("DescribeStacks") 1339 body.Key("Version").String("2010-05-15") 1340 1341 if err := awsAwsquery_serializeOpDocumentDescribeStacksInput(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_serializeOpDescribeStackSet struct { 1363} 1364 1365func (*awsAwsquery_serializeOpDescribeStackSet) ID() string { 1366 return "OperationSerializer" 1367} 1368 1369func (m *awsAwsquery_serializeOpDescribeStackSet) 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.(*DescribeStackSetInput) 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("DescribeStackSet") 1395 body.Key("Version").String("2010-05-15") 1396 1397 if err := awsAwsquery_serializeOpDocumentDescribeStackSetInput(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_serializeOpDescribeStackSetOperation struct { 1419} 1420 1421func (*awsAwsquery_serializeOpDescribeStackSetOperation) ID() string { 1422 return "OperationSerializer" 1423} 1424 1425func (m *awsAwsquery_serializeOpDescribeStackSetOperation) 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.(*DescribeStackSetOperationInput) 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("DescribeStackSetOperation") 1451 body.Key("Version").String("2010-05-15") 1452 1453 if err := awsAwsquery_serializeOpDocumentDescribeStackSetOperationInput(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_serializeOpDescribeType struct { 1475} 1476 1477func (*awsAwsquery_serializeOpDescribeType) ID() string { 1478 return "OperationSerializer" 1479} 1480 1481func (m *awsAwsquery_serializeOpDescribeType) 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.(*DescribeTypeInput) 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("DescribeType") 1507 body.Key("Version").String("2010-05-15") 1508 1509 if err := awsAwsquery_serializeOpDocumentDescribeTypeInput(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_serializeOpDescribeTypeRegistration struct { 1531} 1532 1533func (*awsAwsquery_serializeOpDescribeTypeRegistration) ID() string { 1534 return "OperationSerializer" 1535} 1536 1537func (m *awsAwsquery_serializeOpDescribeTypeRegistration) 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.(*DescribeTypeRegistrationInput) 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("DescribeTypeRegistration") 1563 body.Key("Version").String("2010-05-15") 1564 1565 if err := awsAwsquery_serializeOpDocumentDescribeTypeRegistrationInput(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_serializeOpDetectStackDrift struct { 1587} 1588 1589func (*awsAwsquery_serializeOpDetectStackDrift) ID() string { 1590 return "OperationSerializer" 1591} 1592 1593func (m *awsAwsquery_serializeOpDetectStackDrift) 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.(*DetectStackDriftInput) 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("DetectStackDrift") 1619 body.Key("Version").String("2010-05-15") 1620 1621 if err := awsAwsquery_serializeOpDocumentDetectStackDriftInput(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_serializeOpDetectStackResourceDrift struct { 1643} 1644 1645func (*awsAwsquery_serializeOpDetectStackResourceDrift) ID() string { 1646 return "OperationSerializer" 1647} 1648 1649func (m *awsAwsquery_serializeOpDetectStackResourceDrift) 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.(*DetectStackResourceDriftInput) 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("DetectStackResourceDrift") 1675 body.Key("Version").String("2010-05-15") 1676 1677 if err := awsAwsquery_serializeOpDocumentDetectStackResourceDriftInput(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_serializeOpDetectStackSetDrift struct { 1699} 1700 1701func (*awsAwsquery_serializeOpDetectStackSetDrift) ID() string { 1702 return "OperationSerializer" 1703} 1704 1705func (m *awsAwsquery_serializeOpDetectStackSetDrift) 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.(*DetectStackSetDriftInput) 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("DetectStackSetDrift") 1731 body.Key("Version").String("2010-05-15") 1732 1733 if err := awsAwsquery_serializeOpDocumentDetectStackSetDriftInput(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_serializeOpEstimateTemplateCost struct { 1755} 1756 1757func (*awsAwsquery_serializeOpEstimateTemplateCost) ID() string { 1758 return "OperationSerializer" 1759} 1760 1761func (m *awsAwsquery_serializeOpEstimateTemplateCost) 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.(*EstimateTemplateCostInput) 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("EstimateTemplateCost") 1787 body.Key("Version").String("2010-05-15") 1788 1789 if err := awsAwsquery_serializeOpDocumentEstimateTemplateCostInput(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_serializeOpExecuteChangeSet struct { 1811} 1812 1813func (*awsAwsquery_serializeOpExecuteChangeSet) ID() string { 1814 return "OperationSerializer" 1815} 1816 1817func (m *awsAwsquery_serializeOpExecuteChangeSet) 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.(*ExecuteChangeSetInput) 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("ExecuteChangeSet") 1843 body.Key("Version").String("2010-05-15") 1844 1845 if err := awsAwsquery_serializeOpDocumentExecuteChangeSetInput(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_serializeOpGetStackPolicy struct { 1867} 1868 1869func (*awsAwsquery_serializeOpGetStackPolicy) ID() string { 1870 return "OperationSerializer" 1871} 1872 1873func (m *awsAwsquery_serializeOpGetStackPolicy) 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.(*GetStackPolicyInput) 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("GetStackPolicy") 1899 body.Key("Version").String("2010-05-15") 1900 1901 if err := awsAwsquery_serializeOpDocumentGetStackPolicyInput(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} 1921 1922type awsAwsquery_serializeOpGetTemplate struct { 1923} 1924 1925func (*awsAwsquery_serializeOpGetTemplate) ID() string { 1926 return "OperationSerializer" 1927} 1928 1929func (m *awsAwsquery_serializeOpGetTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1930 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1931) { 1932 request, ok := in.Request.(*smithyhttp.Request) 1933 if !ok { 1934 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1935 } 1936 1937 input, ok := in.Parameters.(*GetTemplateInput) 1938 _ = input 1939 if !ok { 1940 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1941 } 1942 1943 request.Request.URL.Path = "/" 1944 request.Request.Method = "POST" 1945 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1946 if err != nil { 1947 return out, metadata, &smithy.SerializationError{Err: err} 1948 } 1949 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1950 1951 bodyWriter := bytes.NewBuffer(nil) 1952 bodyEncoder := query.NewEncoder(bodyWriter) 1953 body := bodyEncoder.Object() 1954 body.Key("Action").String("GetTemplate") 1955 body.Key("Version").String("2010-05-15") 1956 1957 if err := awsAwsquery_serializeOpDocumentGetTemplateInput(input, bodyEncoder.Value); err != nil { 1958 return out, metadata, &smithy.SerializationError{Err: err} 1959 } 1960 1961 err = bodyEncoder.Encode() 1962 if err != nil { 1963 return out, metadata, &smithy.SerializationError{Err: err} 1964 } 1965 1966 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1967 return out, metadata, &smithy.SerializationError{Err: err} 1968 } 1969 1970 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1971 return out, metadata, &smithy.SerializationError{Err: err} 1972 } 1973 in.Request = request 1974 1975 return next.HandleSerialize(ctx, in) 1976} 1977 1978type awsAwsquery_serializeOpGetTemplateSummary struct { 1979} 1980 1981func (*awsAwsquery_serializeOpGetTemplateSummary) ID() string { 1982 return "OperationSerializer" 1983} 1984 1985func (m *awsAwsquery_serializeOpGetTemplateSummary) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1986 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1987) { 1988 request, ok := in.Request.(*smithyhttp.Request) 1989 if !ok { 1990 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1991 } 1992 1993 input, ok := in.Parameters.(*GetTemplateSummaryInput) 1994 _ = input 1995 if !ok { 1996 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1997 } 1998 1999 request.Request.URL.Path = "/" 2000 request.Request.Method = "POST" 2001 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2002 if err != nil { 2003 return out, metadata, &smithy.SerializationError{Err: err} 2004 } 2005 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2006 2007 bodyWriter := bytes.NewBuffer(nil) 2008 bodyEncoder := query.NewEncoder(bodyWriter) 2009 body := bodyEncoder.Object() 2010 body.Key("Action").String("GetTemplateSummary") 2011 body.Key("Version").String("2010-05-15") 2012 2013 if err := awsAwsquery_serializeOpDocumentGetTemplateSummaryInput(input, bodyEncoder.Value); err != nil { 2014 return out, metadata, &smithy.SerializationError{Err: err} 2015 } 2016 2017 err = bodyEncoder.Encode() 2018 if err != nil { 2019 return out, metadata, &smithy.SerializationError{Err: err} 2020 } 2021 2022 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2023 return out, metadata, &smithy.SerializationError{Err: err} 2024 } 2025 2026 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2027 return out, metadata, &smithy.SerializationError{Err: err} 2028 } 2029 in.Request = request 2030 2031 return next.HandleSerialize(ctx, in) 2032} 2033 2034type awsAwsquery_serializeOpImportStacksToStackSet struct { 2035} 2036 2037func (*awsAwsquery_serializeOpImportStacksToStackSet) ID() string { 2038 return "OperationSerializer" 2039} 2040 2041func (m *awsAwsquery_serializeOpImportStacksToStackSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2042 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2043) { 2044 request, ok := in.Request.(*smithyhttp.Request) 2045 if !ok { 2046 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2047 } 2048 2049 input, ok := in.Parameters.(*ImportStacksToStackSetInput) 2050 _ = input 2051 if !ok { 2052 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2053 } 2054 2055 request.Request.URL.Path = "/" 2056 request.Request.Method = "POST" 2057 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2058 if err != nil { 2059 return out, metadata, &smithy.SerializationError{Err: err} 2060 } 2061 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2062 2063 bodyWriter := bytes.NewBuffer(nil) 2064 bodyEncoder := query.NewEncoder(bodyWriter) 2065 body := bodyEncoder.Object() 2066 body.Key("Action").String("ImportStacksToStackSet") 2067 body.Key("Version").String("2010-05-15") 2068 2069 if err := awsAwsquery_serializeOpDocumentImportStacksToStackSetInput(input, bodyEncoder.Value); err != nil { 2070 return out, metadata, &smithy.SerializationError{Err: err} 2071 } 2072 2073 err = bodyEncoder.Encode() 2074 if err != nil { 2075 return out, metadata, &smithy.SerializationError{Err: err} 2076 } 2077 2078 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2079 return out, metadata, &smithy.SerializationError{Err: err} 2080 } 2081 2082 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2083 return out, metadata, &smithy.SerializationError{Err: err} 2084 } 2085 in.Request = request 2086 2087 return next.HandleSerialize(ctx, in) 2088} 2089 2090type awsAwsquery_serializeOpListChangeSets struct { 2091} 2092 2093func (*awsAwsquery_serializeOpListChangeSets) ID() string { 2094 return "OperationSerializer" 2095} 2096 2097func (m *awsAwsquery_serializeOpListChangeSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2098 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2099) { 2100 request, ok := in.Request.(*smithyhttp.Request) 2101 if !ok { 2102 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2103 } 2104 2105 input, ok := in.Parameters.(*ListChangeSetsInput) 2106 _ = input 2107 if !ok { 2108 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2109 } 2110 2111 request.Request.URL.Path = "/" 2112 request.Request.Method = "POST" 2113 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2114 if err != nil { 2115 return out, metadata, &smithy.SerializationError{Err: err} 2116 } 2117 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2118 2119 bodyWriter := bytes.NewBuffer(nil) 2120 bodyEncoder := query.NewEncoder(bodyWriter) 2121 body := bodyEncoder.Object() 2122 body.Key("Action").String("ListChangeSets") 2123 body.Key("Version").String("2010-05-15") 2124 2125 if err := awsAwsquery_serializeOpDocumentListChangeSetsInput(input, bodyEncoder.Value); err != nil { 2126 return out, metadata, &smithy.SerializationError{Err: err} 2127 } 2128 2129 err = bodyEncoder.Encode() 2130 if err != nil { 2131 return out, metadata, &smithy.SerializationError{Err: err} 2132 } 2133 2134 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2135 return out, metadata, &smithy.SerializationError{Err: err} 2136 } 2137 2138 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2139 return out, metadata, &smithy.SerializationError{Err: err} 2140 } 2141 in.Request = request 2142 2143 return next.HandleSerialize(ctx, in) 2144} 2145 2146type awsAwsquery_serializeOpListExports struct { 2147} 2148 2149func (*awsAwsquery_serializeOpListExports) ID() string { 2150 return "OperationSerializer" 2151} 2152 2153func (m *awsAwsquery_serializeOpListExports) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2154 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2155) { 2156 request, ok := in.Request.(*smithyhttp.Request) 2157 if !ok { 2158 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2159 } 2160 2161 input, ok := in.Parameters.(*ListExportsInput) 2162 _ = input 2163 if !ok { 2164 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2165 } 2166 2167 request.Request.URL.Path = "/" 2168 request.Request.Method = "POST" 2169 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2170 if err != nil { 2171 return out, metadata, &smithy.SerializationError{Err: err} 2172 } 2173 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2174 2175 bodyWriter := bytes.NewBuffer(nil) 2176 bodyEncoder := query.NewEncoder(bodyWriter) 2177 body := bodyEncoder.Object() 2178 body.Key("Action").String("ListExports") 2179 body.Key("Version").String("2010-05-15") 2180 2181 if err := awsAwsquery_serializeOpDocumentListExportsInput(input, bodyEncoder.Value); err != nil { 2182 return out, metadata, &smithy.SerializationError{Err: err} 2183 } 2184 2185 err = bodyEncoder.Encode() 2186 if err != nil { 2187 return out, metadata, &smithy.SerializationError{Err: err} 2188 } 2189 2190 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2191 return out, metadata, &smithy.SerializationError{Err: err} 2192 } 2193 2194 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2195 return out, metadata, &smithy.SerializationError{Err: err} 2196 } 2197 in.Request = request 2198 2199 return next.HandleSerialize(ctx, in) 2200} 2201 2202type awsAwsquery_serializeOpListImports struct { 2203} 2204 2205func (*awsAwsquery_serializeOpListImports) ID() string { 2206 return "OperationSerializer" 2207} 2208 2209func (m *awsAwsquery_serializeOpListImports) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2210 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2211) { 2212 request, ok := in.Request.(*smithyhttp.Request) 2213 if !ok { 2214 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2215 } 2216 2217 input, ok := in.Parameters.(*ListImportsInput) 2218 _ = input 2219 if !ok { 2220 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2221 } 2222 2223 request.Request.URL.Path = "/" 2224 request.Request.Method = "POST" 2225 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2226 if err != nil { 2227 return out, metadata, &smithy.SerializationError{Err: err} 2228 } 2229 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2230 2231 bodyWriter := bytes.NewBuffer(nil) 2232 bodyEncoder := query.NewEncoder(bodyWriter) 2233 body := bodyEncoder.Object() 2234 body.Key("Action").String("ListImports") 2235 body.Key("Version").String("2010-05-15") 2236 2237 if err := awsAwsquery_serializeOpDocumentListImportsInput(input, bodyEncoder.Value); err != nil { 2238 return out, metadata, &smithy.SerializationError{Err: err} 2239 } 2240 2241 err = bodyEncoder.Encode() 2242 if err != nil { 2243 return out, metadata, &smithy.SerializationError{Err: err} 2244 } 2245 2246 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2247 return out, metadata, &smithy.SerializationError{Err: err} 2248 } 2249 2250 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2251 return out, metadata, &smithy.SerializationError{Err: err} 2252 } 2253 in.Request = request 2254 2255 return next.HandleSerialize(ctx, in) 2256} 2257 2258type awsAwsquery_serializeOpListStackInstances struct { 2259} 2260 2261func (*awsAwsquery_serializeOpListStackInstances) ID() string { 2262 return "OperationSerializer" 2263} 2264 2265func (m *awsAwsquery_serializeOpListStackInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2266 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2267) { 2268 request, ok := in.Request.(*smithyhttp.Request) 2269 if !ok { 2270 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2271 } 2272 2273 input, ok := in.Parameters.(*ListStackInstancesInput) 2274 _ = input 2275 if !ok { 2276 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2277 } 2278 2279 request.Request.URL.Path = "/" 2280 request.Request.Method = "POST" 2281 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2282 if err != nil { 2283 return out, metadata, &smithy.SerializationError{Err: err} 2284 } 2285 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2286 2287 bodyWriter := bytes.NewBuffer(nil) 2288 bodyEncoder := query.NewEncoder(bodyWriter) 2289 body := bodyEncoder.Object() 2290 body.Key("Action").String("ListStackInstances") 2291 body.Key("Version").String("2010-05-15") 2292 2293 if err := awsAwsquery_serializeOpDocumentListStackInstancesInput(input, bodyEncoder.Value); err != nil { 2294 return out, metadata, &smithy.SerializationError{Err: err} 2295 } 2296 2297 err = bodyEncoder.Encode() 2298 if err != nil { 2299 return out, metadata, &smithy.SerializationError{Err: err} 2300 } 2301 2302 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2303 return out, metadata, &smithy.SerializationError{Err: err} 2304 } 2305 2306 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2307 return out, metadata, &smithy.SerializationError{Err: err} 2308 } 2309 in.Request = request 2310 2311 return next.HandleSerialize(ctx, in) 2312} 2313 2314type awsAwsquery_serializeOpListStackResources struct { 2315} 2316 2317func (*awsAwsquery_serializeOpListStackResources) ID() string { 2318 return "OperationSerializer" 2319} 2320 2321func (m *awsAwsquery_serializeOpListStackResources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2322 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2323) { 2324 request, ok := in.Request.(*smithyhttp.Request) 2325 if !ok { 2326 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2327 } 2328 2329 input, ok := in.Parameters.(*ListStackResourcesInput) 2330 _ = input 2331 if !ok { 2332 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2333 } 2334 2335 request.Request.URL.Path = "/" 2336 request.Request.Method = "POST" 2337 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2338 if err != nil { 2339 return out, metadata, &smithy.SerializationError{Err: err} 2340 } 2341 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2342 2343 bodyWriter := bytes.NewBuffer(nil) 2344 bodyEncoder := query.NewEncoder(bodyWriter) 2345 body := bodyEncoder.Object() 2346 body.Key("Action").String("ListStackResources") 2347 body.Key("Version").String("2010-05-15") 2348 2349 if err := awsAwsquery_serializeOpDocumentListStackResourcesInput(input, bodyEncoder.Value); err != nil { 2350 return out, metadata, &smithy.SerializationError{Err: err} 2351 } 2352 2353 err = bodyEncoder.Encode() 2354 if err != nil { 2355 return out, metadata, &smithy.SerializationError{Err: err} 2356 } 2357 2358 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2359 return out, metadata, &smithy.SerializationError{Err: err} 2360 } 2361 2362 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2363 return out, metadata, &smithy.SerializationError{Err: err} 2364 } 2365 in.Request = request 2366 2367 return next.HandleSerialize(ctx, in) 2368} 2369 2370type awsAwsquery_serializeOpListStacks struct { 2371} 2372 2373func (*awsAwsquery_serializeOpListStacks) ID() string { 2374 return "OperationSerializer" 2375} 2376 2377func (m *awsAwsquery_serializeOpListStacks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2378 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2379) { 2380 request, ok := in.Request.(*smithyhttp.Request) 2381 if !ok { 2382 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2383 } 2384 2385 input, ok := in.Parameters.(*ListStacksInput) 2386 _ = input 2387 if !ok { 2388 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2389 } 2390 2391 request.Request.URL.Path = "/" 2392 request.Request.Method = "POST" 2393 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2394 if err != nil { 2395 return out, metadata, &smithy.SerializationError{Err: err} 2396 } 2397 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2398 2399 bodyWriter := bytes.NewBuffer(nil) 2400 bodyEncoder := query.NewEncoder(bodyWriter) 2401 body := bodyEncoder.Object() 2402 body.Key("Action").String("ListStacks") 2403 body.Key("Version").String("2010-05-15") 2404 2405 if err := awsAwsquery_serializeOpDocumentListStacksInput(input, bodyEncoder.Value); err != nil { 2406 return out, metadata, &smithy.SerializationError{Err: err} 2407 } 2408 2409 err = bodyEncoder.Encode() 2410 if err != nil { 2411 return out, metadata, &smithy.SerializationError{Err: err} 2412 } 2413 2414 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2415 return out, metadata, &smithy.SerializationError{Err: err} 2416 } 2417 2418 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2419 return out, metadata, &smithy.SerializationError{Err: err} 2420 } 2421 in.Request = request 2422 2423 return next.HandleSerialize(ctx, in) 2424} 2425 2426type awsAwsquery_serializeOpListStackSetOperationResults struct { 2427} 2428 2429func (*awsAwsquery_serializeOpListStackSetOperationResults) ID() string { 2430 return "OperationSerializer" 2431} 2432 2433func (m *awsAwsquery_serializeOpListStackSetOperationResults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2434 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2435) { 2436 request, ok := in.Request.(*smithyhttp.Request) 2437 if !ok { 2438 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2439 } 2440 2441 input, ok := in.Parameters.(*ListStackSetOperationResultsInput) 2442 _ = input 2443 if !ok { 2444 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2445 } 2446 2447 request.Request.URL.Path = "/" 2448 request.Request.Method = "POST" 2449 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2450 if err != nil { 2451 return out, metadata, &smithy.SerializationError{Err: err} 2452 } 2453 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2454 2455 bodyWriter := bytes.NewBuffer(nil) 2456 bodyEncoder := query.NewEncoder(bodyWriter) 2457 body := bodyEncoder.Object() 2458 body.Key("Action").String("ListStackSetOperationResults") 2459 body.Key("Version").String("2010-05-15") 2460 2461 if err := awsAwsquery_serializeOpDocumentListStackSetOperationResultsInput(input, bodyEncoder.Value); err != nil { 2462 return out, metadata, &smithy.SerializationError{Err: err} 2463 } 2464 2465 err = bodyEncoder.Encode() 2466 if err != nil { 2467 return out, metadata, &smithy.SerializationError{Err: err} 2468 } 2469 2470 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2471 return out, metadata, &smithy.SerializationError{Err: err} 2472 } 2473 2474 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2475 return out, metadata, &smithy.SerializationError{Err: err} 2476 } 2477 in.Request = request 2478 2479 return next.HandleSerialize(ctx, in) 2480} 2481 2482type awsAwsquery_serializeOpListStackSetOperations struct { 2483} 2484 2485func (*awsAwsquery_serializeOpListStackSetOperations) ID() string { 2486 return "OperationSerializer" 2487} 2488 2489func (m *awsAwsquery_serializeOpListStackSetOperations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2490 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2491) { 2492 request, ok := in.Request.(*smithyhttp.Request) 2493 if !ok { 2494 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2495 } 2496 2497 input, ok := in.Parameters.(*ListStackSetOperationsInput) 2498 _ = input 2499 if !ok { 2500 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2501 } 2502 2503 request.Request.URL.Path = "/" 2504 request.Request.Method = "POST" 2505 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2506 if err != nil { 2507 return out, metadata, &smithy.SerializationError{Err: err} 2508 } 2509 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2510 2511 bodyWriter := bytes.NewBuffer(nil) 2512 bodyEncoder := query.NewEncoder(bodyWriter) 2513 body := bodyEncoder.Object() 2514 body.Key("Action").String("ListStackSetOperations") 2515 body.Key("Version").String("2010-05-15") 2516 2517 if err := awsAwsquery_serializeOpDocumentListStackSetOperationsInput(input, bodyEncoder.Value); err != nil { 2518 return out, metadata, &smithy.SerializationError{Err: err} 2519 } 2520 2521 err = bodyEncoder.Encode() 2522 if err != nil { 2523 return out, metadata, &smithy.SerializationError{Err: err} 2524 } 2525 2526 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2527 return out, metadata, &smithy.SerializationError{Err: err} 2528 } 2529 2530 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2531 return out, metadata, &smithy.SerializationError{Err: err} 2532 } 2533 in.Request = request 2534 2535 return next.HandleSerialize(ctx, in) 2536} 2537 2538type awsAwsquery_serializeOpListStackSets struct { 2539} 2540 2541func (*awsAwsquery_serializeOpListStackSets) ID() string { 2542 return "OperationSerializer" 2543} 2544 2545func (m *awsAwsquery_serializeOpListStackSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2546 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2547) { 2548 request, ok := in.Request.(*smithyhttp.Request) 2549 if !ok { 2550 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2551 } 2552 2553 input, ok := in.Parameters.(*ListStackSetsInput) 2554 _ = input 2555 if !ok { 2556 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2557 } 2558 2559 request.Request.URL.Path = "/" 2560 request.Request.Method = "POST" 2561 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2562 if err != nil { 2563 return out, metadata, &smithy.SerializationError{Err: err} 2564 } 2565 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2566 2567 bodyWriter := bytes.NewBuffer(nil) 2568 bodyEncoder := query.NewEncoder(bodyWriter) 2569 body := bodyEncoder.Object() 2570 body.Key("Action").String("ListStackSets") 2571 body.Key("Version").String("2010-05-15") 2572 2573 if err := awsAwsquery_serializeOpDocumentListStackSetsInput(input, bodyEncoder.Value); err != nil { 2574 return out, metadata, &smithy.SerializationError{Err: err} 2575 } 2576 2577 err = bodyEncoder.Encode() 2578 if err != nil { 2579 return out, metadata, &smithy.SerializationError{Err: err} 2580 } 2581 2582 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2583 return out, metadata, &smithy.SerializationError{Err: err} 2584 } 2585 2586 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2587 return out, metadata, &smithy.SerializationError{Err: err} 2588 } 2589 in.Request = request 2590 2591 return next.HandleSerialize(ctx, in) 2592} 2593 2594type awsAwsquery_serializeOpListTypeRegistrations struct { 2595} 2596 2597func (*awsAwsquery_serializeOpListTypeRegistrations) ID() string { 2598 return "OperationSerializer" 2599} 2600 2601func (m *awsAwsquery_serializeOpListTypeRegistrations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2602 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2603) { 2604 request, ok := in.Request.(*smithyhttp.Request) 2605 if !ok { 2606 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2607 } 2608 2609 input, ok := in.Parameters.(*ListTypeRegistrationsInput) 2610 _ = input 2611 if !ok { 2612 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2613 } 2614 2615 request.Request.URL.Path = "/" 2616 request.Request.Method = "POST" 2617 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2618 if err != nil { 2619 return out, metadata, &smithy.SerializationError{Err: err} 2620 } 2621 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2622 2623 bodyWriter := bytes.NewBuffer(nil) 2624 bodyEncoder := query.NewEncoder(bodyWriter) 2625 body := bodyEncoder.Object() 2626 body.Key("Action").String("ListTypeRegistrations") 2627 body.Key("Version").String("2010-05-15") 2628 2629 if err := awsAwsquery_serializeOpDocumentListTypeRegistrationsInput(input, bodyEncoder.Value); err != nil { 2630 return out, metadata, &smithy.SerializationError{Err: err} 2631 } 2632 2633 err = bodyEncoder.Encode() 2634 if err != nil { 2635 return out, metadata, &smithy.SerializationError{Err: err} 2636 } 2637 2638 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2639 return out, metadata, &smithy.SerializationError{Err: err} 2640 } 2641 2642 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2643 return out, metadata, &smithy.SerializationError{Err: err} 2644 } 2645 in.Request = request 2646 2647 return next.HandleSerialize(ctx, in) 2648} 2649 2650type awsAwsquery_serializeOpListTypes struct { 2651} 2652 2653func (*awsAwsquery_serializeOpListTypes) ID() string { 2654 return "OperationSerializer" 2655} 2656 2657func (m *awsAwsquery_serializeOpListTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2658 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2659) { 2660 request, ok := in.Request.(*smithyhttp.Request) 2661 if !ok { 2662 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2663 } 2664 2665 input, ok := in.Parameters.(*ListTypesInput) 2666 _ = input 2667 if !ok { 2668 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2669 } 2670 2671 request.Request.URL.Path = "/" 2672 request.Request.Method = "POST" 2673 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2674 if err != nil { 2675 return out, metadata, &smithy.SerializationError{Err: err} 2676 } 2677 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2678 2679 bodyWriter := bytes.NewBuffer(nil) 2680 bodyEncoder := query.NewEncoder(bodyWriter) 2681 body := bodyEncoder.Object() 2682 body.Key("Action").String("ListTypes") 2683 body.Key("Version").String("2010-05-15") 2684 2685 if err := awsAwsquery_serializeOpDocumentListTypesInput(input, bodyEncoder.Value); err != nil { 2686 return out, metadata, &smithy.SerializationError{Err: err} 2687 } 2688 2689 err = bodyEncoder.Encode() 2690 if err != nil { 2691 return out, metadata, &smithy.SerializationError{Err: err} 2692 } 2693 2694 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2695 return out, metadata, &smithy.SerializationError{Err: err} 2696 } 2697 2698 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2699 return out, metadata, &smithy.SerializationError{Err: err} 2700 } 2701 in.Request = request 2702 2703 return next.HandleSerialize(ctx, in) 2704} 2705 2706type awsAwsquery_serializeOpListTypeVersions struct { 2707} 2708 2709func (*awsAwsquery_serializeOpListTypeVersions) ID() string { 2710 return "OperationSerializer" 2711} 2712 2713func (m *awsAwsquery_serializeOpListTypeVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2714 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2715) { 2716 request, ok := in.Request.(*smithyhttp.Request) 2717 if !ok { 2718 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2719 } 2720 2721 input, ok := in.Parameters.(*ListTypeVersionsInput) 2722 _ = input 2723 if !ok { 2724 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2725 } 2726 2727 request.Request.URL.Path = "/" 2728 request.Request.Method = "POST" 2729 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2730 if err != nil { 2731 return out, metadata, &smithy.SerializationError{Err: err} 2732 } 2733 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2734 2735 bodyWriter := bytes.NewBuffer(nil) 2736 bodyEncoder := query.NewEncoder(bodyWriter) 2737 body := bodyEncoder.Object() 2738 body.Key("Action").String("ListTypeVersions") 2739 body.Key("Version").String("2010-05-15") 2740 2741 if err := awsAwsquery_serializeOpDocumentListTypeVersionsInput(input, bodyEncoder.Value); err != nil { 2742 return out, metadata, &smithy.SerializationError{Err: err} 2743 } 2744 2745 err = bodyEncoder.Encode() 2746 if err != nil { 2747 return out, metadata, &smithy.SerializationError{Err: err} 2748 } 2749 2750 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2751 return out, metadata, &smithy.SerializationError{Err: err} 2752 } 2753 2754 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2755 return out, metadata, &smithy.SerializationError{Err: err} 2756 } 2757 in.Request = request 2758 2759 return next.HandleSerialize(ctx, in) 2760} 2761 2762type awsAwsquery_serializeOpPublishType struct { 2763} 2764 2765func (*awsAwsquery_serializeOpPublishType) ID() string { 2766 return "OperationSerializer" 2767} 2768 2769func (m *awsAwsquery_serializeOpPublishType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2770 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2771) { 2772 request, ok := in.Request.(*smithyhttp.Request) 2773 if !ok { 2774 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2775 } 2776 2777 input, ok := in.Parameters.(*PublishTypeInput) 2778 _ = input 2779 if !ok { 2780 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2781 } 2782 2783 request.Request.URL.Path = "/" 2784 request.Request.Method = "POST" 2785 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2786 if err != nil { 2787 return out, metadata, &smithy.SerializationError{Err: err} 2788 } 2789 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2790 2791 bodyWriter := bytes.NewBuffer(nil) 2792 bodyEncoder := query.NewEncoder(bodyWriter) 2793 body := bodyEncoder.Object() 2794 body.Key("Action").String("PublishType") 2795 body.Key("Version").String("2010-05-15") 2796 2797 if err := awsAwsquery_serializeOpDocumentPublishTypeInput(input, bodyEncoder.Value); err != nil { 2798 return out, metadata, &smithy.SerializationError{Err: err} 2799 } 2800 2801 err = bodyEncoder.Encode() 2802 if err != nil { 2803 return out, metadata, &smithy.SerializationError{Err: err} 2804 } 2805 2806 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2807 return out, metadata, &smithy.SerializationError{Err: err} 2808 } 2809 2810 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2811 return out, metadata, &smithy.SerializationError{Err: err} 2812 } 2813 in.Request = request 2814 2815 return next.HandleSerialize(ctx, in) 2816} 2817 2818type awsAwsquery_serializeOpRecordHandlerProgress struct { 2819} 2820 2821func (*awsAwsquery_serializeOpRecordHandlerProgress) ID() string { 2822 return "OperationSerializer" 2823} 2824 2825func (m *awsAwsquery_serializeOpRecordHandlerProgress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2826 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2827) { 2828 request, ok := in.Request.(*smithyhttp.Request) 2829 if !ok { 2830 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2831 } 2832 2833 input, ok := in.Parameters.(*RecordHandlerProgressInput) 2834 _ = input 2835 if !ok { 2836 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2837 } 2838 2839 request.Request.URL.Path = "/" 2840 request.Request.Method = "POST" 2841 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2842 if err != nil { 2843 return out, metadata, &smithy.SerializationError{Err: err} 2844 } 2845 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2846 2847 bodyWriter := bytes.NewBuffer(nil) 2848 bodyEncoder := query.NewEncoder(bodyWriter) 2849 body := bodyEncoder.Object() 2850 body.Key("Action").String("RecordHandlerProgress") 2851 body.Key("Version").String("2010-05-15") 2852 2853 if err := awsAwsquery_serializeOpDocumentRecordHandlerProgressInput(input, bodyEncoder.Value); err != nil { 2854 return out, metadata, &smithy.SerializationError{Err: err} 2855 } 2856 2857 err = bodyEncoder.Encode() 2858 if err != nil { 2859 return out, metadata, &smithy.SerializationError{Err: err} 2860 } 2861 2862 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2863 return out, metadata, &smithy.SerializationError{Err: err} 2864 } 2865 2866 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2867 return out, metadata, &smithy.SerializationError{Err: err} 2868 } 2869 in.Request = request 2870 2871 return next.HandleSerialize(ctx, in) 2872} 2873 2874type awsAwsquery_serializeOpRegisterPublisher struct { 2875} 2876 2877func (*awsAwsquery_serializeOpRegisterPublisher) ID() string { 2878 return "OperationSerializer" 2879} 2880 2881func (m *awsAwsquery_serializeOpRegisterPublisher) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2882 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2883) { 2884 request, ok := in.Request.(*smithyhttp.Request) 2885 if !ok { 2886 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2887 } 2888 2889 input, ok := in.Parameters.(*RegisterPublisherInput) 2890 _ = input 2891 if !ok { 2892 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2893 } 2894 2895 request.Request.URL.Path = "/" 2896 request.Request.Method = "POST" 2897 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2898 if err != nil { 2899 return out, metadata, &smithy.SerializationError{Err: err} 2900 } 2901 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2902 2903 bodyWriter := bytes.NewBuffer(nil) 2904 bodyEncoder := query.NewEncoder(bodyWriter) 2905 body := bodyEncoder.Object() 2906 body.Key("Action").String("RegisterPublisher") 2907 body.Key("Version").String("2010-05-15") 2908 2909 if err := awsAwsquery_serializeOpDocumentRegisterPublisherInput(input, bodyEncoder.Value); err != nil { 2910 return out, metadata, &smithy.SerializationError{Err: err} 2911 } 2912 2913 err = bodyEncoder.Encode() 2914 if err != nil { 2915 return out, metadata, &smithy.SerializationError{Err: err} 2916 } 2917 2918 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2919 return out, metadata, &smithy.SerializationError{Err: err} 2920 } 2921 2922 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2923 return out, metadata, &smithy.SerializationError{Err: err} 2924 } 2925 in.Request = request 2926 2927 return next.HandleSerialize(ctx, in) 2928} 2929 2930type awsAwsquery_serializeOpRegisterType struct { 2931} 2932 2933func (*awsAwsquery_serializeOpRegisterType) ID() string { 2934 return "OperationSerializer" 2935} 2936 2937func (m *awsAwsquery_serializeOpRegisterType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2938 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2939) { 2940 request, ok := in.Request.(*smithyhttp.Request) 2941 if !ok { 2942 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2943 } 2944 2945 input, ok := in.Parameters.(*RegisterTypeInput) 2946 _ = input 2947 if !ok { 2948 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2949 } 2950 2951 request.Request.URL.Path = "/" 2952 request.Request.Method = "POST" 2953 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2954 if err != nil { 2955 return out, metadata, &smithy.SerializationError{Err: err} 2956 } 2957 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2958 2959 bodyWriter := bytes.NewBuffer(nil) 2960 bodyEncoder := query.NewEncoder(bodyWriter) 2961 body := bodyEncoder.Object() 2962 body.Key("Action").String("RegisterType") 2963 body.Key("Version").String("2010-05-15") 2964 2965 if err := awsAwsquery_serializeOpDocumentRegisterTypeInput(input, bodyEncoder.Value); err != nil { 2966 return out, metadata, &smithy.SerializationError{Err: err} 2967 } 2968 2969 err = bodyEncoder.Encode() 2970 if err != nil { 2971 return out, metadata, &smithy.SerializationError{Err: err} 2972 } 2973 2974 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2975 return out, metadata, &smithy.SerializationError{Err: err} 2976 } 2977 2978 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2979 return out, metadata, &smithy.SerializationError{Err: err} 2980 } 2981 in.Request = request 2982 2983 return next.HandleSerialize(ctx, in) 2984} 2985 2986type awsAwsquery_serializeOpRollbackStack struct { 2987} 2988 2989func (*awsAwsquery_serializeOpRollbackStack) ID() string { 2990 return "OperationSerializer" 2991} 2992 2993func (m *awsAwsquery_serializeOpRollbackStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2994 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2995) { 2996 request, ok := in.Request.(*smithyhttp.Request) 2997 if !ok { 2998 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2999 } 3000 3001 input, ok := in.Parameters.(*RollbackStackInput) 3002 _ = input 3003 if !ok { 3004 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3005 } 3006 3007 request.Request.URL.Path = "/" 3008 request.Request.Method = "POST" 3009 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3010 if err != nil { 3011 return out, metadata, &smithy.SerializationError{Err: err} 3012 } 3013 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3014 3015 bodyWriter := bytes.NewBuffer(nil) 3016 bodyEncoder := query.NewEncoder(bodyWriter) 3017 body := bodyEncoder.Object() 3018 body.Key("Action").String("RollbackStack") 3019 body.Key("Version").String("2010-05-15") 3020 3021 if err := awsAwsquery_serializeOpDocumentRollbackStackInput(input, bodyEncoder.Value); err != nil { 3022 return out, metadata, &smithy.SerializationError{Err: err} 3023 } 3024 3025 err = bodyEncoder.Encode() 3026 if err != nil { 3027 return out, metadata, &smithy.SerializationError{Err: err} 3028 } 3029 3030 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3031 return out, metadata, &smithy.SerializationError{Err: err} 3032 } 3033 3034 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3035 return out, metadata, &smithy.SerializationError{Err: err} 3036 } 3037 in.Request = request 3038 3039 return next.HandleSerialize(ctx, in) 3040} 3041 3042type awsAwsquery_serializeOpSetStackPolicy struct { 3043} 3044 3045func (*awsAwsquery_serializeOpSetStackPolicy) ID() string { 3046 return "OperationSerializer" 3047} 3048 3049func (m *awsAwsquery_serializeOpSetStackPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3050 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3051) { 3052 request, ok := in.Request.(*smithyhttp.Request) 3053 if !ok { 3054 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3055 } 3056 3057 input, ok := in.Parameters.(*SetStackPolicyInput) 3058 _ = input 3059 if !ok { 3060 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3061 } 3062 3063 request.Request.URL.Path = "/" 3064 request.Request.Method = "POST" 3065 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3066 if err != nil { 3067 return out, metadata, &smithy.SerializationError{Err: err} 3068 } 3069 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3070 3071 bodyWriter := bytes.NewBuffer(nil) 3072 bodyEncoder := query.NewEncoder(bodyWriter) 3073 body := bodyEncoder.Object() 3074 body.Key("Action").String("SetStackPolicy") 3075 body.Key("Version").String("2010-05-15") 3076 3077 if err := awsAwsquery_serializeOpDocumentSetStackPolicyInput(input, bodyEncoder.Value); err != nil { 3078 return out, metadata, &smithy.SerializationError{Err: err} 3079 } 3080 3081 err = bodyEncoder.Encode() 3082 if err != nil { 3083 return out, metadata, &smithy.SerializationError{Err: err} 3084 } 3085 3086 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3087 return out, metadata, &smithy.SerializationError{Err: err} 3088 } 3089 3090 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3091 return out, metadata, &smithy.SerializationError{Err: err} 3092 } 3093 in.Request = request 3094 3095 return next.HandleSerialize(ctx, in) 3096} 3097 3098type awsAwsquery_serializeOpSetTypeConfiguration struct { 3099} 3100 3101func (*awsAwsquery_serializeOpSetTypeConfiguration) ID() string { 3102 return "OperationSerializer" 3103} 3104 3105func (m *awsAwsquery_serializeOpSetTypeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3106 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3107) { 3108 request, ok := in.Request.(*smithyhttp.Request) 3109 if !ok { 3110 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3111 } 3112 3113 input, ok := in.Parameters.(*SetTypeConfigurationInput) 3114 _ = input 3115 if !ok { 3116 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3117 } 3118 3119 request.Request.URL.Path = "/" 3120 request.Request.Method = "POST" 3121 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3122 if err != nil { 3123 return out, metadata, &smithy.SerializationError{Err: err} 3124 } 3125 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3126 3127 bodyWriter := bytes.NewBuffer(nil) 3128 bodyEncoder := query.NewEncoder(bodyWriter) 3129 body := bodyEncoder.Object() 3130 body.Key("Action").String("SetTypeConfiguration") 3131 body.Key("Version").String("2010-05-15") 3132 3133 if err := awsAwsquery_serializeOpDocumentSetTypeConfigurationInput(input, bodyEncoder.Value); err != nil { 3134 return out, metadata, &smithy.SerializationError{Err: err} 3135 } 3136 3137 err = bodyEncoder.Encode() 3138 if err != nil { 3139 return out, metadata, &smithy.SerializationError{Err: err} 3140 } 3141 3142 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3143 return out, metadata, &smithy.SerializationError{Err: err} 3144 } 3145 3146 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3147 return out, metadata, &smithy.SerializationError{Err: err} 3148 } 3149 in.Request = request 3150 3151 return next.HandleSerialize(ctx, in) 3152} 3153 3154type awsAwsquery_serializeOpSetTypeDefaultVersion struct { 3155} 3156 3157func (*awsAwsquery_serializeOpSetTypeDefaultVersion) ID() string { 3158 return "OperationSerializer" 3159} 3160 3161func (m *awsAwsquery_serializeOpSetTypeDefaultVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3162 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3163) { 3164 request, ok := in.Request.(*smithyhttp.Request) 3165 if !ok { 3166 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3167 } 3168 3169 input, ok := in.Parameters.(*SetTypeDefaultVersionInput) 3170 _ = input 3171 if !ok { 3172 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3173 } 3174 3175 request.Request.URL.Path = "/" 3176 request.Request.Method = "POST" 3177 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3178 if err != nil { 3179 return out, metadata, &smithy.SerializationError{Err: err} 3180 } 3181 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3182 3183 bodyWriter := bytes.NewBuffer(nil) 3184 bodyEncoder := query.NewEncoder(bodyWriter) 3185 body := bodyEncoder.Object() 3186 body.Key("Action").String("SetTypeDefaultVersion") 3187 body.Key("Version").String("2010-05-15") 3188 3189 if err := awsAwsquery_serializeOpDocumentSetTypeDefaultVersionInput(input, bodyEncoder.Value); err != nil { 3190 return out, metadata, &smithy.SerializationError{Err: err} 3191 } 3192 3193 err = bodyEncoder.Encode() 3194 if err != nil { 3195 return out, metadata, &smithy.SerializationError{Err: err} 3196 } 3197 3198 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3199 return out, metadata, &smithy.SerializationError{Err: err} 3200 } 3201 3202 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3203 return out, metadata, &smithy.SerializationError{Err: err} 3204 } 3205 in.Request = request 3206 3207 return next.HandleSerialize(ctx, in) 3208} 3209 3210type awsAwsquery_serializeOpSignalResource struct { 3211} 3212 3213func (*awsAwsquery_serializeOpSignalResource) ID() string { 3214 return "OperationSerializer" 3215} 3216 3217func (m *awsAwsquery_serializeOpSignalResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3218 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3219) { 3220 request, ok := in.Request.(*smithyhttp.Request) 3221 if !ok { 3222 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3223 } 3224 3225 input, ok := in.Parameters.(*SignalResourceInput) 3226 _ = input 3227 if !ok { 3228 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3229 } 3230 3231 request.Request.URL.Path = "/" 3232 request.Request.Method = "POST" 3233 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3234 if err != nil { 3235 return out, metadata, &smithy.SerializationError{Err: err} 3236 } 3237 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3238 3239 bodyWriter := bytes.NewBuffer(nil) 3240 bodyEncoder := query.NewEncoder(bodyWriter) 3241 body := bodyEncoder.Object() 3242 body.Key("Action").String("SignalResource") 3243 body.Key("Version").String("2010-05-15") 3244 3245 if err := awsAwsquery_serializeOpDocumentSignalResourceInput(input, bodyEncoder.Value); err != nil { 3246 return out, metadata, &smithy.SerializationError{Err: err} 3247 } 3248 3249 err = bodyEncoder.Encode() 3250 if err != nil { 3251 return out, metadata, &smithy.SerializationError{Err: err} 3252 } 3253 3254 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3255 return out, metadata, &smithy.SerializationError{Err: err} 3256 } 3257 3258 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3259 return out, metadata, &smithy.SerializationError{Err: err} 3260 } 3261 in.Request = request 3262 3263 return next.HandleSerialize(ctx, in) 3264} 3265 3266type awsAwsquery_serializeOpStopStackSetOperation struct { 3267} 3268 3269func (*awsAwsquery_serializeOpStopStackSetOperation) ID() string { 3270 return "OperationSerializer" 3271} 3272 3273func (m *awsAwsquery_serializeOpStopStackSetOperation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3274 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3275) { 3276 request, ok := in.Request.(*smithyhttp.Request) 3277 if !ok { 3278 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3279 } 3280 3281 input, ok := in.Parameters.(*StopStackSetOperationInput) 3282 _ = input 3283 if !ok { 3284 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3285 } 3286 3287 request.Request.URL.Path = "/" 3288 request.Request.Method = "POST" 3289 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3290 if err != nil { 3291 return out, metadata, &smithy.SerializationError{Err: err} 3292 } 3293 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3294 3295 bodyWriter := bytes.NewBuffer(nil) 3296 bodyEncoder := query.NewEncoder(bodyWriter) 3297 body := bodyEncoder.Object() 3298 body.Key("Action").String("StopStackSetOperation") 3299 body.Key("Version").String("2010-05-15") 3300 3301 if err := awsAwsquery_serializeOpDocumentStopStackSetOperationInput(input, bodyEncoder.Value); err != nil { 3302 return out, metadata, &smithy.SerializationError{Err: err} 3303 } 3304 3305 err = bodyEncoder.Encode() 3306 if err != nil { 3307 return out, metadata, &smithy.SerializationError{Err: err} 3308 } 3309 3310 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3311 return out, metadata, &smithy.SerializationError{Err: err} 3312 } 3313 3314 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3315 return out, metadata, &smithy.SerializationError{Err: err} 3316 } 3317 in.Request = request 3318 3319 return next.HandleSerialize(ctx, in) 3320} 3321 3322type awsAwsquery_serializeOpTestType struct { 3323} 3324 3325func (*awsAwsquery_serializeOpTestType) ID() string { 3326 return "OperationSerializer" 3327} 3328 3329func (m *awsAwsquery_serializeOpTestType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3330 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3331) { 3332 request, ok := in.Request.(*smithyhttp.Request) 3333 if !ok { 3334 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3335 } 3336 3337 input, ok := in.Parameters.(*TestTypeInput) 3338 _ = input 3339 if !ok { 3340 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3341 } 3342 3343 request.Request.URL.Path = "/" 3344 request.Request.Method = "POST" 3345 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3346 if err != nil { 3347 return out, metadata, &smithy.SerializationError{Err: err} 3348 } 3349 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3350 3351 bodyWriter := bytes.NewBuffer(nil) 3352 bodyEncoder := query.NewEncoder(bodyWriter) 3353 body := bodyEncoder.Object() 3354 body.Key("Action").String("TestType") 3355 body.Key("Version").String("2010-05-15") 3356 3357 if err := awsAwsquery_serializeOpDocumentTestTypeInput(input, bodyEncoder.Value); err != nil { 3358 return out, metadata, &smithy.SerializationError{Err: err} 3359 } 3360 3361 err = bodyEncoder.Encode() 3362 if err != nil { 3363 return out, metadata, &smithy.SerializationError{Err: err} 3364 } 3365 3366 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3367 return out, metadata, &smithy.SerializationError{Err: err} 3368 } 3369 3370 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3371 return out, metadata, &smithy.SerializationError{Err: err} 3372 } 3373 in.Request = request 3374 3375 return next.HandleSerialize(ctx, in) 3376} 3377 3378type awsAwsquery_serializeOpUpdateStack struct { 3379} 3380 3381func (*awsAwsquery_serializeOpUpdateStack) ID() string { 3382 return "OperationSerializer" 3383} 3384 3385func (m *awsAwsquery_serializeOpUpdateStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3386 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3387) { 3388 request, ok := in.Request.(*smithyhttp.Request) 3389 if !ok { 3390 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3391 } 3392 3393 input, ok := in.Parameters.(*UpdateStackInput) 3394 _ = input 3395 if !ok { 3396 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3397 } 3398 3399 request.Request.URL.Path = "/" 3400 request.Request.Method = "POST" 3401 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3402 if err != nil { 3403 return out, metadata, &smithy.SerializationError{Err: err} 3404 } 3405 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3406 3407 bodyWriter := bytes.NewBuffer(nil) 3408 bodyEncoder := query.NewEncoder(bodyWriter) 3409 body := bodyEncoder.Object() 3410 body.Key("Action").String("UpdateStack") 3411 body.Key("Version").String("2010-05-15") 3412 3413 if err := awsAwsquery_serializeOpDocumentUpdateStackInput(input, bodyEncoder.Value); err != nil { 3414 return out, metadata, &smithy.SerializationError{Err: err} 3415 } 3416 3417 err = bodyEncoder.Encode() 3418 if err != nil { 3419 return out, metadata, &smithy.SerializationError{Err: err} 3420 } 3421 3422 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3423 return out, metadata, &smithy.SerializationError{Err: err} 3424 } 3425 3426 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3427 return out, metadata, &smithy.SerializationError{Err: err} 3428 } 3429 in.Request = request 3430 3431 return next.HandleSerialize(ctx, in) 3432} 3433 3434type awsAwsquery_serializeOpUpdateStackInstances struct { 3435} 3436 3437func (*awsAwsquery_serializeOpUpdateStackInstances) ID() string { 3438 return "OperationSerializer" 3439} 3440 3441func (m *awsAwsquery_serializeOpUpdateStackInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3442 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3443) { 3444 request, ok := in.Request.(*smithyhttp.Request) 3445 if !ok { 3446 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3447 } 3448 3449 input, ok := in.Parameters.(*UpdateStackInstancesInput) 3450 _ = input 3451 if !ok { 3452 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3453 } 3454 3455 request.Request.URL.Path = "/" 3456 request.Request.Method = "POST" 3457 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3458 if err != nil { 3459 return out, metadata, &smithy.SerializationError{Err: err} 3460 } 3461 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3462 3463 bodyWriter := bytes.NewBuffer(nil) 3464 bodyEncoder := query.NewEncoder(bodyWriter) 3465 body := bodyEncoder.Object() 3466 body.Key("Action").String("UpdateStackInstances") 3467 body.Key("Version").String("2010-05-15") 3468 3469 if err := awsAwsquery_serializeOpDocumentUpdateStackInstancesInput(input, bodyEncoder.Value); err != nil { 3470 return out, metadata, &smithy.SerializationError{Err: err} 3471 } 3472 3473 err = bodyEncoder.Encode() 3474 if err != nil { 3475 return out, metadata, &smithy.SerializationError{Err: err} 3476 } 3477 3478 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3479 return out, metadata, &smithy.SerializationError{Err: err} 3480 } 3481 3482 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3483 return out, metadata, &smithy.SerializationError{Err: err} 3484 } 3485 in.Request = request 3486 3487 return next.HandleSerialize(ctx, in) 3488} 3489 3490type awsAwsquery_serializeOpUpdateStackSet struct { 3491} 3492 3493func (*awsAwsquery_serializeOpUpdateStackSet) ID() string { 3494 return "OperationSerializer" 3495} 3496 3497func (m *awsAwsquery_serializeOpUpdateStackSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3498 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3499) { 3500 request, ok := in.Request.(*smithyhttp.Request) 3501 if !ok { 3502 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3503 } 3504 3505 input, ok := in.Parameters.(*UpdateStackSetInput) 3506 _ = input 3507 if !ok { 3508 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3509 } 3510 3511 request.Request.URL.Path = "/" 3512 request.Request.Method = "POST" 3513 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3514 if err != nil { 3515 return out, metadata, &smithy.SerializationError{Err: err} 3516 } 3517 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3518 3519 bodyWriter := bytes.NewBuffer(nil) 3520 bodyEncoder := query.NewEncoder(bodyWriter) 3521 body := bodyEncoder.Object() 3522 body.Key("Action").String("UpdateStackSet") 3523 body.Key("Version").String("2010-05-15") 3524 3525 if err := awsAwsquery_serializeOpDocumentUpdateStackSetInput(input, bodyEncoder.Value); err != nil { 3526 return out, metadata, &smithy.SerializationError{Err: err} 3527 } 3528 3529 err = bodyEncoder.Encode() 3530 if err != nil { 3531 return out, metadata, &smithy.SerializationError{Err: err} 3532 } 3533 3534 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3535 return out, metadata, &smithy.SerializationError{Err: err} 3536 } 3537 3538 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3539 return out, metadata, &smithy.SerializationError{Err: err} 3540 } 3541 in.Request = request 3542 3543 return next.HandleSerialize(ctx, in) 3544} 3545 3546type awsAwsquery_serializeOpUpdateTerminationProtection struct { 3547} 3548 3549func (*awsAwsquery_serializeOpUpdateTerminationProtection) ID() string { 3550 return "OperationSerializer" 3551} 3552 3553func (m *awsAwsquery_serializeOpUpdateTerminationProtection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3554 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3555) { 3556 request, ok := in.Request.(*smithyhttp.Request) 3557 if !ok { 3558 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3559 } 3560 3561 input, ok := in.Parameters.(*UpdateTerminationProtectionInput) 3562 _ = input 3563 if !ok { 3564 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3565 } 3566 3567 request.Request.URL.Path = "/" 3568 request.Request.Method = "POST" 3569 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3570 if err != nil { 3571 return out, metadata, &smithy.SerializationError{Err: err} 3572 } 3573 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3574 3575 bodyWriter := bytes.NewBuffer(nil) 3576 bodyEncoder := query.NewEncoder(bodyWriter) 3577 body := bodyEncoder.Object() 3578 body.Key("Action").String("UpdateTerminationProtection") 3579 body.Key("Version").String("2010-05-15") 3580 3581 if err := awsAwsquery_serializeOpDocumentUpdateTerminationProtectionInput(input, bodyEncoder.Value); err != nil { 3582 return out, metadata, &smithy.SerializationError{Err: err} 3583 } 3584 3585 err = bodyEncoder.Encode() 3586 if err != nil { 3587 return out, metadata, &smithy.SerializationError{Err: err} 3588 } 3589 3590 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3591 return out, metadata, &smithy.SerializationError{Err: err} 3592 } 3593 3594 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3595 return out, metadata, &smithy.SerializationError{Err: err} 3596 } 3597 in.Request = request 3598 3599 return next.HandleSerialize(ctx, in) 3600} 3601 3602type awsAwsquery_serializeOpValidateTemplate struct { 3603} 3604 3605func (*awsAwsquery_serializeOpValidateTemplate) ID() string { 3606 return "OperationSerializer" 3607} 3608 3609func (m *awsAwsquery_serializeOpValidateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3610 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3611) { 3612 request, ok := in.Request.(*smithyhttp.Request) 3613 if !ok { 3614 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3615 } 3616 3617 input, ok := in.Parameters.(*ValidateTemplateInput) 3618 _ = input 3619 if !ok { 3620 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3621 } 3622 3623 request.Request.URL.Path = "/" 3624 request.Request.Method = "POST" 3625 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3626 if err != nil { 3627 return out, metadata, &smithy.SerializationError{Err: err} 3628 } 3629 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3630 3631 bodyWriter := bytes.NewBuffer(nil) 3632 bodyEncoder := query.NewEncoder(bodyWriter) 3633 body := bodyEncoder.Object() 3634 body.Key("Action").String("ValidateTemplate") 3635 body.Key("Version").String("2010-05-15") 3636 3637 if err := awsAwsquery_serializeOpDocumentValidateTemplateInput(input, bodyEncoder.Value); err != nil { 3638 return out, metadata, &smithy.SerializationError{Err: err} 3639 } 3640 3641 err = bodyEncoder.Encode() 3642 if err != nil { 3643 return out, metadata, &smithy.SerializationError{Err: err} 3644 } 3645 3646 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3647 return out, metadata, &smithy.SerializationError{Err: err} 3648 } 3649 3650 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3651 return out, metadata, &smithy.SerializationError{Err: err} 3652 } 3653 in.Request = request 3654 3655 return next.HandleSerialize(ctx, in) 3656} 3657func awsAwsquery_serializeDocumentAccountList(v []string, value query.Value) error { 3658 if len(v) == 0 { 3659 return nil 3660 } 3661 array := value.Array("member") 3662 3663 for i := range v { 3664 av := array.Value() 3665 av.String(v[i]) 3666 } 3667 return nil 3668} 3669 3670func awsAwsquery_serializeDocumentAutoDeployment(v *types.AutoDeployment, value query.Value) error { 3671 object := value.Object() 3672 _ = object 3673 3674 if v.Enabled != nil { 3675 objectKey := object.Key("Enabled") 3676 objectKey.Boolean(*v.Enabled) 3677 } 3678 3679 if v.RetainStacksOnAccountRemoval != nil { 3680 objectKey := object.Key("RetainStacksOnAccountRemoval") 3681 objectKey.Boolean(*v.RetainStacksOnAccountRemoval) 3682 } 3683 3684 return nil 3685} 3686 3687func awsAwsquery_serializeDocumentCapabilities(v []types.Capability, value query.Value) error { 3688 if len(v) == 0 { 3689 return nil 3690 } 3691 array := value.Array("member") 3692 3693 for i := range v { 3694 av := array.Value() 3695 av.String(string(v[i])) 3696 } 3697 return nil 3698} 3699 3700func awsAwsquery_serializeDocumentDeploymentTargets(v *types.DeploymentTargets, value query.Value) error { 3701 object := value.Object() 3702 _ = object 3703 3704 if v.Accounts != nil { 3705 objectKey := object.Key("Accounts") 3706 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 3707 return err 3708 } 3709 } 3710 3711 if v.AccountsUrl != nil { 3712 objectKey := object.Key("AccountsUrl") 3713 objectKey.String(*v.AccountsUrl) 3714 } 3715 3716 if v.OrganizationalUnitIds != nil { 3717 objectKey := object.Key("OrganizationalUnitIds") 3718 if err := awsAwsquery_serializeDocumentOrganizationalUnitIdList(v.OrganizationalUnitIds, objectKey); err != nil { 3719 return err 3720 } 3721 } 3722 3723 return nil 3724} 3725 3726func awsAwsquery_serializeDocumentLoggingConfig(v *types.LoggingConfig, value query.Value) error { 3727 object := value.Object() 3728 _ = object 3729 3730 if v.LogGroupName != nil { 3731 objectKey := object.Key("LogGroupName") 3732 objectKey.String(*v.LogGroupName) 3733 } 3734 3735 if v.LogRoleArn != nil { 3736 objectKey := object.Key("LogRoleArn") 3737 objectKey.String(*v.LogRoleArn) 3738 } 3739 3740 return nil 3741} 3742 3743func awsAwsquery_serializeDocumentLogicalResourceIds(v []string, value query.Value) error { 3744 if len(v) == 0 { 3745 return nil 3746 } 3747 array := value.Array("member") 3748 3749 for i := range v { 3750 av := array.Value() 3751 av.String(v[i]) 3752 } 3753 return nil 3754} 3755 3756func awsAwsquery_serializeDocumentNotificationARNs(v []string, value query.Value) error { 3757 if len(v) == 0 { 3758 return nil 3759 } 3760 array := value.Array("member") 3761 3762 for i := range v { 3763 av := array.Value() 3764 av.String(v[i]) 3765 } 3766 return nil 3767} 3768 3769func awsAwsquery_serializeDocumentOrganizationalUnitIdList(v []string, value query.Value) error { 3770 if len(v) == 0 { 3771 return nil 3772 } 3773 array := value.Array("member") 3774 3775 for i := range v { 3776 av := array.Value() 3777 av.String(v[i]) 3778 } 3779 return nil 3780} 3781 3782func awsAwsquery_serializeDocumentParameter(v *types.Parameter, value query.Value) error { 3783 object := value.Object() 3784 _ = object 3785 3786 if v.ParameterKey != nil { 3787 objectKey := object.Key("ParameterKey") 3788 objectKey.String(*v.ParameterKey) 3789 } 3790 3791 if v.ParameterValue != nil { 3792 objectKey := object.Key("ParameterValue") 3793 objectKey.String(*v.ParameterValue) 3794 } 3795 3796 if v.ResolvedValue != nil { 3797 objectKey := object.Key("ResolvedValue") 3798 objectKey.String(*v.ResolvedValue) 3799 } 3800 3801 if v.UsePreviousValue != nil { 3802 objectKey := object.Key("UsePreviousValue") 3803 objectKey.Boolean(*v.UsePreviousValue) 3804 } 3805 3806 return nil 3807} 3808 3809func awsAwsquery_serializeDocumentParameters(v []types.Parameter, value query.Value) error { 3810 if len(v) == 0 { 3811 return nil 3812 } 3813 array := value.Array("member") 3814 3815 for i := range v { 3816 av := array.Value() 3817 if err := awsAwsquery_serializeDocumentParameter(&v[i], av); err != nil { 3818 return err 3819 } 3820 } 3821 return nil 3822} 3823 3824func awsAwsquery_serializeDocumentRegionList(v []string, value query.Value) error { 3825 if len(v) == 0 { 3826 return nil 3827 } 3828 array := value.Array("member") 3829 3830 for i := range v { 3831 av := array.Value() 3832 av.String(v[i]) 3833 } 3834 return nil 3835} 3836 3837func awsAwsquery_serializeDocumentResourceIdentifierProperties(v map[string]string, value query.Value) error { 3838 if len(v) == 0 { 3839 return nil 3840 } 3841 object := value.Map("key", "value") 3842 3843 keys := make([]string, 0, len(v)) 3844 for key := range v { 3845 keys = append(keys, key) 3846 } 3847 sort.Strings(keys) 3848 3849 for _, key := range keys { 3850 om := object.Key(key) 3851 om.String(v[key]) 3852 } 3853 return nil 3854} 3855 3856func awsAwsquery_serializeDocumentResourcesToImport(v []types.ResourceToImport, value query.Value) error { 3857 if len(v) == 0 { 3858 return nil 3859 } 3860 array := value.Array("member") 3861 3862 for i := range v { 3863 av := array.Value() 3864 if err := awsAwsquery_serializeDocumentResourceToImport(&v[i], av); err != nil { 3865 return err 3866 } 3867 } 3868 return nil 3869} 3870 3871func awsAwsquery_serializeDocumentResourcesToSkip(v []string, value query.Value) error { 3872 if len(v) == 0 { 3873 return nil 3874 } 3875 array := value.Array("member") 3876 3877 for i := range v { 3878 av := array.Value() 3879 av.String(v[i]) 3880 } 3881 return nil 3882} 3883 3884func awsAwsquery_serializeDocumentResourceToImport(v *types.ResourceToImport, value query.Value) error { 3885 object := value.Object() 3886 _ = object 3887 3888 if v.LogicalResourceId != nil { 3889 objectKey := object.Key("LogicalResourceId") 3890 objectKey.String(*v.LogicalResourceId) 3891 } 3892 3893 if v.ResourceIdentifier != nil { 3894 objectKey := object.Key("ResourceIdentifier") 3895 if err := awsAwsquery_serializeDocumentResourceIdentifierProperties(v.ResourceIdentifier, objectKey); err != nil { 3896 return err 3897 } 3898 } 3899 3900 if v.ResourceType != nil { 3901 objectKey := object.Key("ResourceType") 3902 objectKey.String(*v.ResourceType) 3903 } 3904 3905 return nil 3906} 3907 3908func awsAwsquery_serializeDocumentResourceTypes(v []string, value query.Value) error { 3909 if len(v) == 0 { 3910 return nil 3911 } 3912 array := value.Array("member") 3913 3914 for i := range v { 3915 av := array.Value() 3916 av.String(v[i]) 3917 } 3918 return nil 3919} 3920 3921func awsAwsquery_serializeDocumentRetainResources(v []string, value query.Value) error { 3922 if len(v) == 0 { 3923 return nil 3924 } 3925 array := value.Array("member") 3926 3927 for i := range v { 3928 av := array.Value() 3929 av.String(v[i]) 3930 } 3931 return nil 3932} 3933 3934func awsAwsquery_serializeDocumentRollbackConfiguration(v *types.RollbackConfiguration, value query.Value) error { 3935 object := value.Object() 3936 _ = object 3937 3938 if v.MonitoringTimeInMinutes != nil { 3939 objectKey := object.Key("MonitoringTimeInMinutes") 3940 objectKey.Integer(*v.MonitoringTimeInMinutes) 3941 } 3942 3943 if v.RollbackTriggers != nil { 3944 objectKey := object.Key("RollbackTriggers") 3945 if err := awsAwsquery_serializeDocumentRollbackTriggers(v.RollbackTriggers, objectKey); err != nil { 3946 return err 3947 } 3948 } 3949 3950 return nil 3951} 3952 3953func awsAwsquery_serializeDocumentRollbackTrigger(v *types.RollbackTrigger, value query.Value) error { 3954 object := value.Object() 3955 _ = object 3956 3957 if v.Arn != nil { 3958 objectKey := object.Key("Arn") 3959 objectKey.String(*v.Arn) 3960 } 3961 3962 if v.Type != nil { 3963 objectKey := object.Key("Type") 3964 objectKey.String(*v.Type) 3965 } 3966 3967 return nil 3968} 3969 3970func awsAwsquery_serializeDocumentRollbackTriggers(v []types.RollbackTrigger, value query.Value) error { 3971 if len(v) == 0 { 3972 return nil 3973 } 3974 array := value.Array("member") 3975 3976 for i := range v { 3977 av := array.Value() 3978 if err := awsAwsquery_serializeDocumentRollbackTrigger(&v[i], av); err != nil { 3979 return err 3980 } 3981 } 3982 return nil 3983} 3984 3985func awsAwsquery_serializeDocumentStackIdList(v []string, value query.Value) error { 3986 if len(v) == 0 { 3987 return nil 3988 } 3989 array := value.Array("member") 3990 3991 for i := range v { 3992 av := array.Value() 3993 av.String(v[i]) 3994 } 3995 return nil 3996} 3997 3998func awsAwsquery_serializeDocumentStackInstanceFilter(v *types.StackInstanceFilter, value query.Value) error { 3999 object := value.Object() 4000 _ = object 4001 4002 if len(v.Name) > 0 { 4003 objectKey := object.Key("Name") 4004 objectKey.String(string(v.Name)) 4005 } 4006 4007 if v.Values != nil { 4008 objectKey := object.Key("Values") 4009 objectKey.String(*v.Values) 4010 } 4011 4012 return nil 4013} 4014 4015func awsAwsquery_serializeDocumentStackInstanceFilters(v []types.StackInstanceFilter, value query.Value) error { 4016 if len(v) == 0 { 4017 return nil 4018 } 4019 array := value.Array("member") 4020 4021 for i := range v { 4022 av := array.Value() 4023 if err := awsAwsquery_serializeDocumentStackInstanceFilter(&v[i], av); err != nil { 4024 return err 4025 } 4026 } 4027 return nil 4028} 4029 4030func awsAwsquery_serializeDocumentStackResourceDriftStatusFilters(v []types.StackResourceDriftStatus, value query.Value) error { 4031 if len(v) == 0 { 4032 return nil 4033 } 4034 array := value.Array("member") 4035 4036 for i := range v { 4037 av := array.Value() 4038 av.String(string(v[i])) 4039 } 4040 return nil 4041} 4042 4043func awsAwsquery_serializeDocumentStackSetOperationPreferences(v *types.StackSetOperationPreferences, value query.Value) error { 4044 object := value.Object() 4045 _ = object 4046 4047 if v.FailureToleranceCount != nil { 4048 objectKey := object.Key("FailureToleranceCount") 4049 objectKey.Integer(*v.FailureToleranceCount) 4050 } 4051 4052 if v.FailureTolerancePercentage != nil { 4053 objectKey := object.Key("FailureTolerancePercentage") 4054 objectKey.Integer(*v.FailureTolerancePercentage) 4055 } 4056 4057 if v.MaxConcurrentCount != nil { 4058 objectKey := object.Key("MaxConcurrentCount") 4059 objectKey.Integer(*v.MaxConcurrentCount) 4060 } 4061 4062 if v.MaxConcurrentPercentage != nil { 4063 objectKey := object.Key("MaxConcurrentPercentage") 4064 objectKey.Integer(*v.MaxConcurrentPercentage) 4065 } 4066 4067 if len(v.RegionConcurrencyType) > 0 { 4068 objectKey := object.Key("RegionConcurrencyType") 4069 objectKey.String(string(v.RegionConcurrencyType)) 4070 } 4071 4072 if v.RegionOrder != nil { 4073 objectKey := object.Key("RegionOrder") 4074 if err := awsAwsquery_serializeDocumentRegionList(v.RegionOrder, objectKey); err != nil { 4075 return err 4076 } 4077 } 4078 4079 return nil 4080} 4081 4082func awsAwsquery_serializeDocumentStackStatusFilter(v []types.StackStatus, value query.Value) error { 4083 if len(v) == 0 { 4084 return nil 4085 } 4086 array := value.Array("member") 4087 4088 for i := range v { 4089 av := array.Value() 4090 av.String(string(v[i])) 4091 } 4092 return nil 4093} 4094 4095func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error { 4096 object := value.Object() 4097 _ = object 4098 4099 if v.Key != nil { 4100 objectKey := object.Key("Key") 4101 objectKey.String(*v.Key) 4102 } 4103 4104 if v.Value != nil { 4105 objectKey := object.Key("Value") 4106 objectKey.String(*v.Value) 4107 } 4108 4109 return nil 4110} 4111 4112func awsAwsquery_serializeDocumentTags(v []types.Tag, value query.Value) error { 4113 if len(v) == 0 { 4114 return nil 4115 } 4116 array := value.Array("member") 4117 4118 for i := range v { 4119 av := array.Value() 4120 if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil { 4121 return err 4122 } 4123 } 4124 return nil 4125} 4126 4127func awsAwsquery_serializeDocumentTypeConfigurationIdentifier(v *types.TypeConfigurationIdentifier, value query.Value) error { 4128 object := value.Object() 4129 _ = object 4130 4131 if len(v.Type) > 0 { 4132 objectKey := object.Key("Type") 4133 objectKey.String(string(v.Type)) 4134 } 4135 4136 if v.TypeArn != nil { 4137 objectKey := object.Key("TypeArn") 4138 objectKey.String(*v.TypeArn) 4139 } 4140 4141 if v.TypeConfigurationAlias != nil { 4142 objectKey := object.Key("TypeConfigurationAlias") 4143 objectKey.String(*v.TypeConfigurationAlias) 4144 } 4145 4146 if v.TypeConfigurationArn != nil { 4147 objectKey := object.Key("TypeConfigurationArn") 4148 objectKey.String(*v.TypeConfigurationArn) 4149 } 4150 4151 if v.TypeName != nil { 4152 objectKey := object.Key("TypeName") 4153 objectKey.String(*v.TypeName) 4154 } 4155 4156 return nil 4157} 4158 4159func awsAwsquery_serializeDocumentTypeConfigurationIdentifiers(v []types.TypeConfigurationIdentifier, value query.Value) error { 4160 if len(v) == 0 { 4161 return nil 4162 } 4163 array := value.Array("member") 4164 4165 for i := range v { 4166 av := array.Value() 4167 if err := awsAwsquery_serializeDocumentTypeConfigurationIdentifier(&v[i], av); err != nil { 4168 return err 4169 } 4170 } 4171 return nil 4172} 4173 4174func awsAwsquery_serializeDocumentTypeFilters(v *types.TypeFilters, value query.Value) error { 4175 object := value.Object() 4176 _ = object 4177 4178 if len(v.Category) > 0 { 4179 objectKey := object.Key("Category") 4180 objectKey.String(string(v.Category)) 4181 } 4182 4183 if v.PublisherId != nil { 4184 objectKey := object.Key("PublisherId") 4185 objectKey.String(*v.PublisherId) 4186 } 4187 4188 if v.TypeNamePrefix != nil { 4189 objectKey := object.Key("TypeNamePrefix") 4190 objectKey.String(*v.TypeNamePrefix) 4191 } 4192 4193 return nil 4194} 4195 4196func awsAwsquery_serializeOpDocumentActivateTypeInput(v *ActivateTypeInput, value query.Value) error { 4197 object := value.Object() 4198 _ = object 4199 4200 if v.AutoUpdate != nil { 4201 objectKey := object.Key("AutoUpdate") 4202 objectKey.Boolean(*v.AutoUpdate) 4203 } 4204 4205 if v.ExecutionRoleArn != nil { 4206 objectKey := object.Key("ExecutionRoleArn") 4207 objectKey.String(*v.ExecutionRoleArn) 4208 } 4209 4210 if v.LoggingConfig != nil { 4211 objectKey := object.Key("LoggingConfig") 4212 if err := awsAwsquery_serializeDocumentLoggingConfig(v.LoggingConfig, objectKey); err != nil { 4213 return err 4214 } 4215 } 4216 4217 if v.MajorVersion != nil { 4218 objectKey := object.Key("MajorVersion") 4219 objectKey.Long(*v.MajorVersion) 4220 } 4221 4222 if v.PublicTypeArn != nil { 4223 objectKey := object.Key("PublicTypeArn") 4224 objectKey.String(*v.PublicTypeArn) 4225 } 4226 4227 if v.PublisherId != nil { 4228 objectKey := object.Key("PublisherId") 4229 objectKey.String(*v.PublisherId) 4230 } 4231 4232 if len(v.Type) > 0 { 4233 objectKey := object.Key("Type") 4234 objectKey.String(string(v.Type)) 4235 } 4236 4237 if v.TypeName != nil { 4238 objectKey := object.Key("TypeName") 4239 objectKey.String(*v.TypeName) 4240 } 4241 4242 if v.TypeNameAlias != nil { 4243 objectKey := object.Key("TypeNameAlias") 4244 objectKey.String(*v.TypeNameAlias) 4245 } 4246 4247 if len(v.VersionBump) > 0 { 4248 objectKey := object.Key("VersionBump") 4249 objectKey.String(string(v.VersionBump)) 4250 } 4251 4252 return nil 4253} 4254 4255func awsAwsquery_serializeOpDocumentBatchDescribeTypeConfigurationsInput(v *BatchDescribeTypeConfigurationsInput, value query.Value) error { 4256 object := value.Object() 4257 _ = object 4258 4259 if v.TypeConfigurationIdentifiers != nil { 4260 objectKey := object.Key("TypeConfigurationIdentifiers") 4261 if err := awsAwsquery_serializeDocumentTypeConfigurationIdentifiers(v.TypeConfigurationIdentifiers, objectKey); err != nil { 4262 return err 4263 } 4264 } 4265 4266 return nil 4267} 4268 4269func awsAwsquery_serializeOpDocumentCancelUpdateStackInput(v *CancelUpdateStackInput, value query.Value) error { 4270 object := value.Object() 4271 _ = object 4272 4273 if v.ClientRequestToken != nil { 4274 objectKey := object.Key("ClientRequestToken") 4275 objectKey.String(*v.ClientRequestToken) 4276 } 4277 4278 if v.StackName != nil { 4279 objectKey := object.Key("StackName") 4280 objectKey.String(*v.StackName) 4281 } 4282 4283 return nil 4284} 4285 4286func awsAwsquery_serializeOpDocumentContinueUpdateRollbackInput(v *ContinueUpdateRollbackInput, value query.Value) error { 4287 object := value.Object() 4288 _ = object 4289 4290 if v.ClientRequestToken != nil { 4291 objectKey := object.Key("ClientRequestToken") 4292 objectKey.String(*v.ClientRequestToken) 4293 } 4294 4295 if v.ResourcesToSkip != nil { 4296 objectKey := object.Key("ResourcesToSkip") 4297 if err := awsAwsquery_serializeDocumentResourcesToSkip(v.ResourcesToSkip, objectKey); err != nil { 4298 return err 4299 } 4300 } 4301 4302 if v.RoleARN != nil { 4303 objectKey := object.Key("RoleARN") 4304 objectKey.String(*v.RoleARN) 4305 } 4306 4307 if v.StackName != nil { 4308 objectKey := object.Key("StackName") 4309 objectKey.String(*v.StackName) 4310 } 4311 4312 return nil 4313} 4314 4315func awsAwsquery_serializeOpDocumentCreateChangeSetInput(v *CreateChangeSetInput, value query.Value) error { 4316 object := value.Object() 4317 _ = object 4318 4319 if v.Capabilities != nil { 4320 objectKey := object.Key("Capabilities") 4321 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 4322 return err 4323 } 4324 } 4325 4326 if v.ChangeSetName != nil { 4327 objectKey := object.Key("ChangeSetName") 4328 objectKey.String(*v.ChangeSetName) 4329 } 4330 4331 if len(v.ChangeSetType) > 0 { 4332 objectKey := object.Key("ChangeSetType") 4333 objectKey.String(string(v.ChangeSetType)) 4334 } 4335 4336 if v.ClientToken != nil { 4337 objectKey := object.Key("ClientToken") 4338 objectKey.String(*v.ClientToken) 4339 } 4340 4341 if v.Description != nil { 4342 objectKey := object.Key("Description") 4343 objectKey.String(*v.Description) 4344 } 4345 4346 if v.IncludeNestedStacks != nil { 4347 objectKey := object.Key("IncludeNestedStacks") 4348 objectKey.Boolean(*v.IncludeNestedStacks) 4349 } 4350 4351 if v.NotificationARNs != nil { 4352 objectKey := object.Key("NotificationARNs") 4353 if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil { 4354 return err 4355 } 4356 } 4357 4358 if v.Parameters != nil { 4359 objectKey := object.Key("Parameters") 4360 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 4361 return err 4362 } 4363 } 4364 4365 if v.ResourcesToImport != nil { 4366 objectKey := object.Key("ResourcesToImport") 4367 if err := awsAwsquery_serializeDocumentResourcesToImport(v.ResourcesToImport, objectKey); err != nil { 4368 return err 4369 } 4370 } 4371 4372 if v.ResourceTypes != nil { 4373 objectKey := object.Key("ResourceTypes") 4374 if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil { 4375 return err 4376 } 4377 } 4378 4379 if v.RoleARN != nil { 4380 objectKey := object.Key("RoleARN") 4381 objectKey.String(*v.RoleARN) 4382 } 4383 4384 if v.RollbackConfiguration != nil { 4385 objectKey := object.Key("RollbackConfiguration") 4386 if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil { 4387 return err 4388 } 4389 } 4390 4391 if v.StackName != nil { 4392 objectKey := object.Key("StackName") 4393 objectKey.String(*v.StackName) 4394 } 4395 4396 if v.Tags != nil { 4397 objectKey := object.Key("Tags") 4398 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 4399 return err 4400 } 4401 } 4402 4403 if v.TemplateBody != nil { 4404 objectKey := object.Key("TemplateBody") 4405 objectKey.String(*v.TemplateBody) 4406 } 4407 4408 if v.TemplateURL != nil { 4409 objectKey := object.Key("TemplateURL") 4410 objectKey.String(*v.TemplateURL) 4411 } 4412 4413 if v.UsePreviousTemplate != nil { 4414 objectKey := object.Key("UsePreviousTemplate") 4415 objectKey.Boolean(*v.UsePreviousTemplate) 4416 } 4417 4418 return nil 4419} 4420 4421func awsAwsquery_serializeOpDocumentCreateStackInput(v *CreateStackInput, value query.Value) error { 4422 object := value.Object() 4423 _ = object 4424 4425 if v.Capabilities != nil { 4426 objectKey := object.Key("Capabilities") 4427 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 4428 return err 4429 } 4430 } 4431 4432 if v.ClientRequestToken != nil { 4433 objectKey := object.Key("ClientRequestToken") 4434 objectKey.String(*v.ClientRequestToken) 4435 } 4436 4437 if v.DisableRollback != nil { 4438 objectKey := object.Key("DisableRollback") 4439 objectKey.Boolean(*v.DisableRollback) 4440 } 4441 4442 if v.EnableTerminationProtection != nil { 4443 objectKey := object.Key("EnableTerminationProtection") 4444 objectKey.Boolean(*v.EnableTerminationProtection) 4445 } 4446 4447 if v.NotificationARNs != nil { 4448 objectKey := object.Key("NotificationARNs") 4449 if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil { 4450 return err 4451 } 4452 } 4453 4454 if len(v.OnFailure) > 0 { 4455 objectKey := object.Key("OnFailure") 4456 objectKey.String(string(v.OnFailure)) 4457 } 4458 4459 if v.Parameters != nil { 4460 objectKey := object.Key("Parameters") 4461 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 4462 return err 4463 } 4464 } 4465 4466 if v.ResourceTypes != nil { 4467 objectKey := object.Key("ResourceTypes") 4468 if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil { 4469 return err 4470 } 4471 } 4472 4473 if v.RoleARN != nil { 4474 objectKey := object.Key("RoleARN") 4475 objectKey.String(*v.RoleARN) 4476 } 4477 4478 if v.RollbackConfiguration != nil { 4479 objectKey := object.Key("RollbackConfiguration") 4480 if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil { 4481 return err 4482 } 4483 } 4484 4485 if v.StackName != nil { 4486 objectKey := object.Key("StackName") 4487 objectKey.String(*v.StackName) 4488 } 4489 4490 if v.StackPolicyBody != nil { 4491 objectKey := object.Key("StackPolicyBody") 4492 objectKey.String(*v.StackPolicyBody) 4493 } 4494 4495 if v.StackPolicyURL != nil { 4496 objectKey := object.Key("StackPolicyURL") 4497 objectKey.String(*v.StackPolicyURL) 4498 } 4499 4500 if v.Tags != nil { 4501 objectKey := object.Key("Tags") 4502 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 4503 return err 4504 } 4505 } 4506 4507 if v.TemplateBody != nil { 4508 objectKey := object.Key("TemplateBody") 4509 objectKey.String(*v.TemplateBody) 4510 } 4511 4512 if v.TemplateURL != nil { 4513 objectKey := object.Key("TemplateURL") 4514 objectKey.String(*v.TemplateURL) 4515 } 4516 4517 if v.TimeoutInMinutes != nil { 4518 objectKey := object.Key("TimeoutInMinutes") 4519 objectKey.Integer(*v.TimeoutInMinutes) 4520 } 4521 4522 return nil 4523} 4524 4525func awsAwsquery_serializeOpDocumentCreateStackInstancesInput(v *CreateStackInstancesInput, value query.Value) error { 4526 object := value.Object() 4527 _ = object 4528 4529 if v.Accounts != nil { 4530 objectKey := object.Key("Accounts") 4531 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 4532 return err 4533 } 4534 } 4535 4536 if len(v.CallAs) > 0 { 4537 objectKey := object.Key("CallAs") 4538 objectKey.String(string(v.CallAs)) 4539 } 4540 4541 if v.DeploymentTargets != nil { 4542 objectKey := object.Key("DeploymentTargets") 4543 if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil { 4544 return err 4545 } 4546 } 4547 4548 if v.OperationId != nil { 4549 objectKey := object.Key("OperationId") 4550 objectKey.String(*v.OperationId) 4551 } 4552 4553 if v.OperationPreferences != nil { 4554 objectKey := object.Key("OperationPreferences") 4555 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 4556 return err 4557 } 4558 } 4559 4560 if v.ParameterOverrides != nil { 4561 objectKey := object.Key("ParameterOverrides") 4562 if err := awsAwsquery_serializeDocumentParameters(v.ParameterOverrides, objectKey); err != nil { 4563 return err 4564 } 4565 } 4566 4567 if v.Regions != nil { 4568 objectKey := object.Key("Regions") 4569 if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil { 4570 return err 4571 } 4572 } 4573 4574 if v.StackSetName != nil { 4575 objectKey := object.Key("StackSetName") 4576 objectKey.String(*v.StackSetName) 4577 } 4578 4579 return nil 4580} 4581 4582func awsAwsquery_serializeOpDocumentCreateStackSetInput(v *CreateStackSetInput, value query.Value) error { 4583 object := value.Object() 4584 _ = object 4585 4586 if v.AdministrationRoleARN != nil { 4587 objectKey := object.Key("AdministrationRoleARN") 4588 objectKey.String(*v.AdministrationRoleARN) 4589 } 4590 4591 if v.AutoDeployment != nil { 4592 objectKey := object.Key("AutoDeployment") 4593 if err := awsAwsquery_serializeDocumentAutoDeployment(v.AutoDeployment, objectKey); err != nil { 4594 return err 4595 } 4596 } 4597 4598 if len(v.CallAs) > 0 { 4599 objectKey := object.Key("CallAs") 4600 objectKey.String(string(v.CallAs)) 4601 } 4602 4603 if v.Capabilities != nil { 4604 objectKey := object.Key("Capabilities") 4605 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 4606 return err 4607 } 4608 } 4609 4610 if v.ClientRequestToken != nil { 4611 objectKey := object.Key("ClientRequestToken") 4612 objectKey.String(*v.ClientRequestToken) 4613 } 4614 4615 if v.Description != nil { 4616 objectKey := object.Key("Description") 4617 objectKey.String(*v.Description) 4618 } 4619 4620 if v.ExecutionRoleName != nil { 4621 objectKey := object.Key("ExecutionRoleName") 4622 objectKey.String(*v.ExecutionRoleName) 4623 } 4624 4625 if v.Parameters != nil { 4626 objectKey := object.Key("Parameters") 4627 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 4628 return err 4629 } 4630 } 4631 4632 if len(v.PermissionModel) > 0 { 4633 objectKey := object.Key("PermissionModel") 4634 objectKey.String(string(v.PermissionModel)) 4635 } 4636 4637 if v.StackId != nil { 4638 objectKey := object.Key("StackId") 4639 objectKey.String(*v.StackId) 4640 } 4641 4642 if v.StackSetName != nil { 4643 objectKey := object.Key("StackSetName") 4644 objectKey.String(*v.StackSetName) 4645 } 4646 4647 if v.Tags != nil { 4648 objectKey := object.Key("Tags") 4649 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 4650 return err 4651 } 4652 } 4653 4654 if v.TemplateBody != nil { 4655 objectKey := object.Key("TemplateBody") 4656 objectKey.String(*v.TemplateBody) 4657 } 4658 4659 if v.TemplateURL != nil { 4660 objectKey := object.Key("TemplateURL") 4661 objectKey.String(*v.TemplateURL) 4662 } 4663 4664 return nil 4665} 4666 4667func awsAwsquery_serializeOpDocumentDeactivateTypeInput(v *DeactivateTypeInput, value query.Value) error { 4668 object := value.Object() 4669 _ = object 4670 4671 if v.Arn != nil { 4672 objectKey := object.Key("Arn") 4673 objectKey.String(*v.Arn) 4674 } 4675 4676 if len(v.Type) > 0 { 4677 objectKey := object.Key("Type") 4678 objectKey.String(string(v.Type)) 4679 } 4680 4681 if v.TypeName != nil { 4682 objectKey := object.Key("TypeName") 4683 objectKey.String(*v.TypeName) 4684 } 4685 4686 return nil 4687} 4688 4689func awsAwsquery_serializeOpDocumentDeleteChangeSetInput(v *DeleteChangeSetInput, value query.Value) error { 4690 object := value.Object() 4691 _ = object 4692 4693 if v.ChangeSetName != nil { 4694 objectKey := object.Key("ChangeSetName") 4695 objectKey.String(*v.ChangeSetName) 4696 } 4697 4698 if v.StackName != nil { 4699 objectKey := object.Key("StackName") 4700 objectKey.String(*v.StackName) 4701 } 4702 4703 return nil 4704} 4705 4706func awsAwsquery_serializeOpDocumentDeleteStackInput(v *DeleteStackInput, value query.Value) error { 4707 object := value.Object() 4708 _ = object 4709 4710 if v.ClientRequestToken != nil { 4711 objectKey := object.Key("ClientRequestToken") 4712 objectKey.String(*v.ClientRequestToken) 4713 } 4714 4715 if v.RetainResources != nil { 4716 objectKey := object.Key("RetainResources") 4717 if err := awsAwsquery_serializeDocumentRetainResources(v.RetainResources, objectKey); err != nil { 4718 return err 4719 } 4720 } 4721 4722 if v.RoleARN != nil { 4723 objectKey := object.Key("RoleARN") 4724 objectKey.String(*v.RoleARN) 4725 } 4726 4727 if v.StackName != nil { 4728 objectKey := object.Key("StackName") 4729 objectKey.String(*v.StackName) 4730 } 4731 4732 return nil 4733} 4734 4735func awsAwsquery_serializeOpDocumentDeleteStackInstancesInput(v *DeleteStackInstancesInput, value query.Value) error { 4736 object := value.Object() 4737 _ = object 4738 4739 if v.Accounts != nil { 4740 objectKey := object.Key("Accounts") 4741 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 4742 return err 4743 } 4744 } 4745 4746 if len(v.CallAs) > 0 { 4747 objectKey := object.Key("CallAs") 4748 objectKey.String(string(v.CallAs)) 4749 } 4750 4751 if v.DeploymentTargets != nil { 4752 objectKey := object.Key("DeploymentTargets") 4753 if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil { 4754 return err 4755 } 4756 } 4757 4758 if v.OperationId != nil { 4759 objectKey := object.Key("OperationId") 4760 objectKey.String(*v.OperationId) 4761 } 4762 4763 if v.OperationPreferences != nil { 4764 objectKey := object.Key("OperationPreferences") 4765 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 4766 return err 4767 } 4768 } 4769 4770 if v.Regions != nil { 4771 objectKey := object.Key("Regions") 4772 if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil { 4773 return err 4774 } 4775 } 4776 4777 { 4778 objectKey := object.Key("RetainStacks") 4779 objectKey.Boolean(v.RetainStacks) 4780 } 4781 4782 if v.StackSetName != nil { 4783 objectKey := object.Key("StackSetName") 4784 objectKey.String(*v.StackSetName) 4785 } 4786 4787 return nil 4788} 4789 4790func awsAwsquery_serializeOpDocumentDeleteStackSetInput(v *DeleteStackSetInput, value query.Value) error { 4791 object := value.Object() 4792 _ = object 4793 4794 if len(v.CallAs) > 0 { 4795 objectKey := object.Key("CallAs") 4796 objectKey.String(string(v.CallAs)) 4797 } 4798 4799 if v.StackSetName != nil { 4800 objectKey := object.Key("StackSetName") 4801 objectKey.String(*v.StackSetName) 4802 } 4803 4804 return nil 4805} 4806 4807func awsAwsquery_serializeOpDocumentDeregisterTypeInput(v *DeregisterTypeInput, value query.Value) error { 4808 object := value.Object() 4809 _ = object 4810 4811 if v.Arn != nil { 4812 objectKey := object.Key("Arn") 4813 objectKey.String(*v.Arn) 4814 } 4815 4816 if len(v.Type) > 0 { 4817 objectKey := object.Key("Type") 4818 objectKey.String(string(v.Type)) 4819 } 4820 4821 if v.TypeName != nil { 4822 objectKey := object.Key("TypeName") 4823 objectKey.String(*v.TypeName) 4824 } 4825 4826 if v.VersionId != nil { 4827 objectKey := object.Key("VersionId") 4828 objectKey.String(*v.VersionId) 4829 } 4830 4831 return nil 4832} 4833 4834func awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(v *DescribeAccountLimitsInput, value query.Value) error { 4835 object := value.Object() 4836 _ = object 4837 4838 if v.NextToken != nil { 4839 objectKey := object.Key("NextToken") 4840 objectKey.String(*v.NextToken) 4841 } 4842 4843 return nil 4844} 4845 4846func awsAwsquery_serializeOpDocumentDescribeChangeSetInput(v *DescribeChangeSetInput, value query.Value) error { 4847 object := value.Object() 4848 _ = object 4849 4850 if v.ChangeSetName != nil { 4851 objectKey := object.Key("ChangeSetName") 4852 objectKey.String(*v.ChangeSetName) 4853 } 4854 4855 if v.NextToken != nil { 4856 objectKey := object.Key("NextToken") 4857 objectKey.String(*v.NextToken) 4858 } 4859 4860 if v.StackName != nil { 4861 objectKey := object.Key("StackName") 4862 objectKey.String(*v.StackName) 4863 } 4864 4865 return nil 4866} 4867 4868func awsAwsquery_serializeOpDocumentDescribePublisherInput(v *DescribePublisherInput, value query.Value) error { 4869 object := value.Object() 4870 _ = object 4871 4872 if v.PublisherId != nil { 4873 objectKey := object.Key("PublisherId") 4874 objectKey.String(*v.PublisherId) 4875 } 4876 4877 return nil 4878} 4879 4880func awsAwsquery_serializeOpDocumentDescribeStackDriftDetectionStatusInput(v *DescribeStackDriftDetectionStatusInput, value query.Value) error { 4881 object := value.Object() 4882 _ = object 4883 4884 if v.StackDriftDetectionId != nil { 4885 objectKey := object.Key("StackDriftDetectionId") 4886 objectKey.String(*v.StackDriftDetectionId) 4887 } 4888 4889 return nil 4890} 4891 4892func awsAwsquery_serializeOpDocumentDescribeStackEventsInput(v *DescribeStackEventsInput, value query.Value) error { 4893 object := value.Object() 4894 _ = object 4895 4896 if v.NextToken != nil { 4897 objectKey := object.Key("NextToken") 4898 objectKey.String(*v.NextToken) 4899 } 4900 4901 if v.StackName != nil { 4902 objectKey := object.Key("StackName") 4903 objectKey.String(*v.StackName) 4904 } 4905 4906 return nil 4907} 4908 4909func awsAwsquery_serializeOpDocumentDescribeStackInstanceInput(v *DescribeStackInstanceInput, value query.Value) error { 4910 object := value.Object() 4911 _ = object 4912 4913 if len(v.CallAs) > 0 { 4914 objectKey := object.Key("CallAs") 4915 objectKey.String(string(v.CallAs)) 4916 } 4917 4918 if v.StackInstanceAccount != nil { 4919 objectKey := object.Key("StackInstanceAccount") 4920 objectKey.String(*v.StackInstanceAccount) 4921 } 4922 4923 if v.StackInstanceRegion != nil { 4924 objectKey := object.Key("StackInstanceRegion") 4925 objectKey.String(*v.StackInstanceRegion) 4926 } 4927 4928 if v.StackSetName != nil { 4929 objectKey := object.Key("StackSetName") 4930 objectKey.String(*v.StackSetName) 4931 } 4932 4933 return nil 4934} 4935 4936func awsAwsquery_serializeOpDocumentDescribeStackResourceDriftsInput(v *DescribeStackResourceDriftsInput, value query.Value) error { 4937 object := value.Object() 4938 _ = object 4939 4940 if v.MaxResults != nil { 4941 objectKey := object.Key("MaxResults") 4942 objectKey.Integer(*v.MaxResults) 4943 } 4944 4945 if v.NextToken != nil { 4946 objectKey := object.Key("NextToken") 4947 objectKey.String(*v.NextToken) 4948 } 4949 4950 if v.StackName != nil { 4951 objectKey := object.Key("StackName") 4952 objectKey.String(*v.StackName) 4953 } 4954 4955 if v.StackResourceDriftStatusFilters != nil { 4956 objectKey := object.Key("StackResourceDriftStatusFilters") 4957 if err := awsAwsquery_serializeDocumentStackResourceDriftStatusFilters(v.StackResourceDriftStatusFilters, objectKey); err != nil { 4958 return err 4959 } 4960 } 4961 4962 return nil 4963} 4964 4965func awsAwsquery_serializeOpDocumentDescribeStackResourceInput(v *DescribeStackResourceInput, value query.Value) error { 4966 object := value.Object() 4967 _ = object 4968 4969 if v.LogicalResourceId != nil { 4970 objectKey := object.Key("LogicalResourceId") 4971 objectKey.String(*v.LogicalResourceId) 4972 } 4973 4974 if v.StackName != nil { 4975 objectKey := object.Key("StackName") 4976 objectKey.String(*v.StackName) 4977 } 4978 4979 return nil 4980} 4981 4982func awsAwsquery_serializeOpDocumentDescribeStackResourcesInput(v *DescribeStackResourcesInput, value query.Value) error { 4983 object := value.Object() 4984 _ = object 4985 4986 if v.LogicalResourceId != nil { 4987 objectKey := object.Key("LogicalResourceId") 4988 objectKey.String(*v.LogicalResourceId) 4989 } 4990 4991 if v.PhysicalResourceId != nil { 4992 objectKey := object.Key("PhysicalResourceId") 4993 objectKey.String(*v.PhysicalResourceId) 4994 } 4995 4996 if v.StackName != nil { 4997 objectKey := object.Key("StackName") 4998 objectKey.String(*v.StackName) 4999 } 5000 5001 return nil 5002} 5003 5004func awsAwsquery_serializeOpDocumentDescribeStackSetInput(v *DescribeStackSetInput, value query.Value) error { 5005 object := value.Object() 5006 _ = object 5007 5008 if len(v.CallAs) > 0 { 5009 objectKey := object.Key("CallAs") 5010 objectKey.String(string(v.CallAs)) 5011 } 5012 5013 if v.StackSetName != nil { 5014 objectKey := object.Key("StackSetName") 5015 objectKey.String(*v.StackSetName) 5016 } 5017 5018 return nil 5019} 5020 5021func awsAwsquery_serializeOpDocumentDescribeStackSetOperationInput(v *DescribeStackSetOperationInput, value query.Value) error { 5022 object := value.Object() 5023 _ = object 5024 5025 if len(v.CallAs) > 0 { 5026 objectKey := object.Key("CallAs") 5027 objectKey.String(string(v.CallAs)) 5028 } 5029 5030 if v.OperationId != nil { 5031 objectKey := object.Key("OperationId") 5032 objectKey.String(*v.OperationId) 5033 } 5034 5035 if v.StackSetName != nil { 5036 objectKey := object.Key("StackSetName") 5037 objectKey.String(*v.StackSetName) 5038 } 5039 5040 return nil 5041} 5042 5043func awsAwsquery_serializeOpDocumentDescribeStacksInput(v *DescribeStacksInput, value query.Value) error { 5044 object := value.Object() 5045 _ = object 5046 5047 if v.NextToken != nil { 5048 objectKey := object.Key("NextToken") 5049 objectKey.String(*v.NextToken) 5050 } 5051 5052 if v.StackName != nil { 5053 objectKey := object.Key("StackName") 5054 objectKey.String(*v.StackName) 5055 } 5056 5057 return nil 5058} 5059 5060func awsAwsquery_serializeOpDocumentDescribeTypeInput(v *DescribeTypeInput, value query.Value) error { 5061 object := value.Object() 5062 _ = object 5063 5064 if v.Arn != nil { 5065 objectKey := object.Key("Arn") 5066 objectKey.String(*v.Arn) 5067 } 5068 5069 if v.PublicVersionNumber != nil { 5070 objectKey := object.Key("PublicVersionNumber") 5071 objectKey.String(*v.PublicVersionNumber) 5072 } 5073 5074 if v.PublisherId != nil { 5075 objectKey := object.Key("PublisherId") 5076 objectKey.String(*v.PublisherId) 5077 } 5078 5079 if len(v.Type) > 0 { 5080 objectKey := object.Key("Type") 5081 objectKey.String(string(v.Type)) 5082 } 5083 5084 if v.TypeName != nil { 5085 objectKey := object.Key("TypeName") 5086 objectKey.String(*v.TypeName) 5087 } 5088 5089 if v.VersionId != nil { 5090 objectKey := object.Key("VersionId") 5091 objectKey.String(*v.VersionId) 5092 } 5093 5094 return nil 5095} 5096 5097func awsAwsquery_serializeOpDocumentDescribeTypeRegistrationInput(v *DescribeTypeRegistrationInput, value query.Value) error { 5098 object := value.Object() 5099 _ = object 5100 5101 if v.RegistrationToken != nil { 5102 objectKey := object.Key("RegistrationToken") 5103 objectKey.String(*v.RegistrationToken) 5104 } 5105 5106 return nil 5107} 5108 5109func awsAwsquery_serializeOpDocumentDetectStackDriftInput(v *DetectStackDriftInput, value query.Value) error { 5110 object := value.Object() 5111 _ = object 5112 5113 if v.LogicalResourceIds != nil { 5114 objectKey := object.Key("LogicalResourceIds") 5115 if err := awsAwsquery_serializeDocumentLogicalResourceIds(v.LogicalResourceIds, objectKey); err != nil { 5116 return err 5117 } 5118 } 5119 5120 if v.StackName != nil { 5121 objectKey := object.Key("StackName") 5122 objectKey.String(*v.StackName) 5123 } 5124 5125 return nil 5126} 5127 5128func awsAwsquery_serializeOpDocumentDetectStackResourceDriftInput(v *DetectStackResourceDriftInput, value query.Value) error { 5129 object := value.Object() 5130 _ = object 5131 5132 if v.LogicalResourceId != nil { 5133 objectKey := object.Key("LogicalResourceId") 5134 objectKey.String(*v.LogicalResourceId) 5135 } 5136 5137 if v.StackName != nil { 5138 objectKey := object.Key("StackName") 5139 objectKey.String(*v.StackName) 5140 } 5141 5142 return nil 5143} 5144 5145func awsAwsquery_serializeOpDocumentDetectStackSetDriftInput(v *DetectStackSetDriftInput, value query.Value) error { 5146 object := value.Object() 5147 _ = object 5148 5149 if len(v.CallAs) > 0 { 5150 objectKey := object.Key("CallAs") 5151 objectKey.String(string(v.CallAs)) 5152 } 5153 5154 if v.OperationId != nil { 5155 objectKey := object.Key("OperationId") 5156 objectKey.String(*v.OperationId) 5157 } 5158 5159 if v.OperationPreferences != nil { 5160 objectKey := object.Key("OperationPreferences") 5161 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 5162 return err 5163 } 5164 } 5165 5166 if v.StackSetName != nil { 5167 objectKey := object.Key("StackSetName") 5168 objectKey.String(*v.StackSetName) 5169 } 5170 5171 return nil 5172} 5173 5174func awsAwsquery_serializeOpDocumentEstimateTemplateCostInput(v *EstimateTemplateCostInput, value query.Value) error { 5175 object := value.Object() 5176 _ = object 5177 5178 if v.Parameters != nil { 5179 objectKey := object.Key("Parameters") 5180 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 5181 return err 5182 } 5183 } 5184 5185 if v.TemplateBody != nil { 5186 objectKey := object.Key("TemplateBody") 5187 objectKey.String(*v.TemplateBody) 5188 } 5189 5190 if v.TemplateURL != nil { 5191 objectKey := object.Key("TemplateURL") 5192 objectKey.String(*v.TemplateURL) 5193 } 5194 5195 return nil 5196} 5197 5198func awsAwsquery_serializeOpDocumentExecuteChangeSetInput(v *ExecuteChangeSetInput, value query.Value) error { 5199 object := value.Object() 5200 _ = object 5201 5202 if v.ChangeSetName != nil { 5203 objectKey := object.Key("ChangeSetName") 5204 objectKey.String(*v.ChangeSetName) 5205 } 5206 5207 if v.ClientRequestToken != nil { 5208 objectKey := object.Key("ClientRequestToken") 5209 objectKey.String(*v.ClientRequestToken) 5210 } 5211 5212 if v.DisableRollback != nil { 5213 objectKey := object.Key("DisableRollback") 5214 objectKey.Boolean(*v.DisableRollback) 5215 } 5216 5217 if v.StackName != nil { 5218 objectKey := object.Key("StackName") 5219 objectKey.String(*v.StackName) 5220 } 5221 5222 return nil 5223} 5224 5225func awsAwsquery_serializeOpDocumentGetStackPolicyInput(v *GetStackPolicyInput, value query.Value) error { 5226 object := value.Object() 5227 _ = object 5228 5229 if v.StackName != nil { 5230 objectKey := object.Key("StackName") 5231 objectKey.String(*v.StackName) 5232 } 5233 5234 return nil 5235} 5236 5237func awsAwsquery_serializeOpDocumentGetTemplateInput(v *GetTemplateInput, value query.Value) error { 5238 object := value.Object() 5239 _ = object 5240 5241 if v.ChangeSetName != nil { 5242 objectKey := object.Key("ChangeSetName") 5243 objectKey.String(*v.ChangeSetName) 5244 } 5245 5246 if v.StackName != nil { 5247 objectKey := object.Key("StackName") 5248 objectKey.String(*v.StackName) 5249 } 5250 5251 if len(v.TemplateStage) > 0 { 5252 objectKey := object.Key("TemplateStage") 5253 objectKey.String(string(v.TemplateStage)) 5254 } 5255 5256 return nil 5257} 5258 5259func awsAwsquery_serializeOpDocumentGetTemplateSummaryInput(v *GetTemplateSummaryInput, value query.Value) error { 5260 object := value.Object() 5261 _ = object 5262 5263 if len(v.CallAs) > 0 { 5264 objectKey := object.Key("CallAs") 5265 objectKey.String(string(v.CallAs)) 5266 } 5267 5268 if v.StackName != nil { 5269 objectKey := object.Key("StackName") 5270 objectKey.String(*v.StackName) 5271 } 5272 5273 if v.StackSetName != nil { 5274 objectKey := object.Key("StackSetName") 5275 objectKey.String(*v.StackSetName) 5276 } 5277 5278 if v.TemplateBody != nil { 5279 objectKey := object.Key("TemplateBody") 5280 objectKey.String(*v.TemplateBody) 5281 } 5282 5283 if v.TemplateURL != nil { 5284 objectKey := object.Key("TemplateURL") 5285 objectKey.String(*v.TemplateURL) 5286 } 5287 5288 return nil 5289} 5290 5291func awsAwsquery_serializeOpDocumentImportStacksToStackSetInput(v *ImportStacksToStackSetInput, value query.Value) error { 5292 object := value.Object() 5293 _ = object 5294 5295 if len(v.CallAs) > 0 { 5296 objectKey := object.Key("CallAs") 5297 objectKey.String(string(v.CallAs)) 5298 } 5299 5300 if v.OperationId != nil { 5301 objectKey := object.Key("OperationId") 5302 objectKey.String(*v.OperationId) 5303 } 5304 5305 if v.OperationPreferences != nil { 5306 objectKey := object.Key("OperationPreferences") 5307 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 5308 return err 5309 } 5310 } 5311 5312 if v.StackIds != nil { 5313 objectKey := object.Key("StackIds") 5314 if err := awsAwsquery_serializeDocumentStackIdList(v.StackIds, objectKey); err != nil { 5315 return err 5316 } 5317 } 5318 5319 if v.StackSetName != nil { 5320 objectKey := object.Key("StackSetName") 5321 objectKey.String(*v.StackSetName) 5322 } 5323 5324 return nil 5325} 5326 5327func awsAwsquery_serializeOpDocumentListChangeSetsInput(v *ListChangeSetsInput, value query.Value) error { 5328 object := value.Object() 5329 _ = object 5330 5331 if v.NextToken != nil { 5332 objectKey := object.Key("NextToken") 5333 objectKey.String(*v.NextToken) 5334 } 5335 5336 if v.StackName != nil { 5337 objectKey := object.Key("StackName") 5338 objectKey.String(*v.StackName) 5339 } 5340 5341 return nil 5342} 5343 5344func awsAwsquery_serializeOpDocumentListExportsInput(v *ListExportsInput, value query.Value) error { 5345 object := value.Object() 5346 _ = object 5347 5348 if v.NextToken != nil { 5349 objectKey := object.Key("NextToken") 5350 objectKey.String(*v.NextToken) 5351 } 5352 5353 return nil 5354} 5355 5356func awsAwsquery_serializeOpDocumentListImportsInput(v *ListImportsInput, value query.Value) error { 5357 object := value.Object() 5358 _ = object 5359 5360 if v.ExportName != nil { 5361 objectKey := object.Key("ExportName") 5362 objectKey.String(*v.ExportName) 5363 } 5364 5365 if v.NextToken != nil { 5366 objectKey := object.Key("NextToken") 5367 objectKey.String(*v.NextToken) 5368 } 5369 5370 return nil 5371} 5372 5373func awsAwsquery_serializeOpDocumentListStackInstancesInput(v *ListStackInstancesInput, value query.Value) error { 5374 object := value.Object() 5375 _ = object 5376 5377 if len(v.CallAs) > 0 { 5378 objectKey := object.Key("CallAs") 5379 objectKey.String(string(v.CallAs)) 5380 } 5381 5382 if v.Filters != nil { 5383 objectKey := object.Key("Filters") 5384 if err := awsAwsquery_serializeDocumentStackInstanceFilters(v.Filters, objectKey); err != nil { 5385 return err 5386 } 5387 } 5388 5389 if v.MaxResults != nil { 5390 objectKey := object.Key("MaxResults") 5391 objectKey.Integer(*v.MaxResults) 5392 } 5393 5394 if v.NextToken != nil { 5395 objectKey := object.Key("NextToken") 5396 objectKey.String(*v.NextToken) 5397 } 5398 5399 if v.StackInstanceAccount != nil { 5400 objectKey := object.Key("StackInstanceAccount") 5401 objectKey.String(*v.StackInstanceAccount) 5402 } 5403 5404 if v.StackInstanceRegion != nil { 5405 objectKey := object.Key("StackInstanceRegion") 5406 objectKey.String(*v.StackInstanceRegion) 5407 } 5408 5409 if v.StackSetName != nil { 5410 objectKey := object.Key("StackSetName") 5411 objectKey.String(*v.StackSetName) 5412 } 5413 5414 return nil 5415} 5416 5417func awsAwsquery_serializeOpDocumentListStackResourcesInput(v *ListStackResourcesInput, value query.Value) error { 5418 object := value.Object() 5419 _ = object 5420 5421 if v.NextToken != nil { 5422 objectKey := object.Key("NextToken") 5423 objectKey.String(*v.NextToken) 5424 } 5425 5426 if v.StackName != nil { 5427 objectKey := object.Key("StackName") 5428 objectKey.String(*v.StackName) 5429 } 5430 5431 return nil 5432} 5433 5434func awsAwsquery_serializeOpDocumentListStackSetOperationResultsInput(v *ListStackSetOperationResultsInput, value query.Value) error { 5435 object := value.Object() 5436 _ = object 5437 5438 if len(v.CallAs) > 0 { 5439 objectKey := object.Key("CallAs") 5440 objectKey.String(string(v.CallAs)) 5441 } 5442 5443 if v.MaxResults != nil { 5444 objectKey := object.Key("MaxResults") 5445 objectKey.Integer(*v.MaxResults) 5446 } 5447 5448 if v.NextToken != nil { 5449 objectKey := object.Key("NextToken") 5450 objectKey.String(*v.NextToken) 5451 } 5452 5453 if v.OperationId != nil { 5454 objectKey := object.Key("OperationId") 5455 objectKey.String(*v.OperationId) 5456 } 5457 5458 if v.StackSetName != nil { 5459 objectKey := object.Key("StackSetName") 5460 objectKey.String(*v.StackSetName) 5461 } 5462 5463 return nil 5464} 5465 5466func awsAwsquery_serializeOpDocumentListStackSetOperationsInput(v *ListStackSetOperationsInput, value query.Value) error { 5467 object := value.Object() 5468 _ = object 5469 5470 if len(v.CallAs) > 0 { 5471 objectKey := object.Key("CallAs") 5472 objectKey.String(string(v.CallAs)) 5473 } 5474 5475 if v.MaxResults != nil { 5476 objectKey := object.Key("MaxResults") 5477 objectKey.Integer(*v.MaxResults) 5478 } 5479 5480 if v.NextToken != nil { 5481 objectKey := object.Key("NextToken") 5482 objectKey.String(*v.NextToken) 5483 } 5484 5485 if v.StackSetName != nil { 5486 objectKey := object.Key("StackSetName") 5487 objectKey.String(*v.StackSetName) 5488 } 5489 5490 return nil 5491} 5492 5493func awsAwsquery_serializeOpDocumentListStackSetsInput(v *ListStackSetsInput, value query.Value) error { 5494 object := value.Object() 5495 _ = object 5496 5497 if len(v.CallAs) > 0 { 5498 objectKey := object.Key("CallAs") 5499 objectKey.String(string(v.CallAs)) 5500 } 5501 5502 if v.MaxResults != nil { 5503 objectKey := object.Key("MaxResults") 5504 objectKey.Integer(*v.MaxResults) 5505 } 5506 5507 if v.NextToken != nil { 5508 objectKey := object.Key("NextToken") 5509 objectKey.String(*v.NextToken) 5510 } 5511 5512 if len(v.Status) > 0 { 5513 objectKey := object.Key("Status") 5514 objectKey.String(string(v.Status)) 5515 } 5516 5517 return nil 5518} 5519 5520func awsAwsquery_serializeOpDocumentListStacksInput(v *ListStacksInput, value query.Value) error { 5521 object := value.Object() 5522 _ = object 5523 5524 if v.NextToken != nil { 5525 objectKey := object.Key("NextToken") 5526 objectKey.String(*v.NextToken) 5527 } 5528 5529 if v.StackStatusFilter != nil { 5530 objectKey := object.Key("StackStatusFilter") 5531 if err := awsAwsquery_serializeDocumentStackStatusFilter(v.StackStatusFilter, objectKey); err != nil { 5532 return err 5533 } 5534 } 5535 5536 return nil 5537} 5538 5539func awsAwsquery_serializeOpDocumentListTypeRegistrationsInput(v *ListTypeRegistrationsInput, value query.Value) error { 5540 object := value.Object() 5541 _ = object 5542 5543 if v.MaxResults != nil { 5544 objectKey := object.Key("MaxResults") 5545 objectKey.Integer(*v.MaxResults) 5546 } 5547 5548 if v.NextToken != nil { 5549 objectKey := object.Key("NextToken") 5550 objectKey.String(*v.NextToken) 5551 } 5552 5553 if len(v.RegistrationStatusFilter) > 0 { 5554 objectKey := object.Key("RegistrationStatusFilter") 5555 objectKey.String(string(v.RegistrationStatusFilter)) 5556 } 5557 5558 if len(v.Type) > 0 { 5559 objectKey := object.Key("Type") 5560 objectKey.String(string(v.Type)) 5561 } 5562 5563 if v.TypeArn != nil { 5564 objectKey := object.Key("TypeArn") 5565 objectKey.String(*v.TypeArn) 5566 } 5567 5568 if v.TypeName != nil { 5569 objectKey := object.Key("TypeName") 5570 objectKey.String(*v.TypeName) 5571 } 5572 5573 return nil 5574} 5575 5576func awsAwsquery_serializeOpDocumentListTypesInput(v *ListTypesInput, value query.Value) error { 5577 object := value.Object() 5578 _ = object 5579 5580 if len(v.DeprecatedStatus) > 0 { 5581 objectKey := object.Key("DeprecatedStatus") 5582 objectKey.String(string(v.DeprecatedStatus)) 5583 } 5584 5585 if v.Filters != nil { 5586 objectKey := object.Key("Filters") 5587 if err := awsAwsquery_serializeDocumentTypeFilters(v.Filters, objectKey); err != nil { 5588 return err 5589 } 5590 } 5591 5592 if v.MaxResults != nil { 5593 objectKey := object.Key("MaxResults") 5594 objectKey.Integer(*v.MaxResults) 5595 } 5596 5597 if v.NextToken != nil { 5598 objectKey := object.Key("NextToken") 5599 objectKey.String(*v.NextToken) 5600 } 5601 5602 if len(v.ProvisioningType) > 0 { 5603 objectKey := object.Key("ProvisioningType") 5604 objectKey.String(string(v.ProvisioningType)) 5605 } 5606 5607 if len(v.Type) > 0 { 5608 objectKey := object.Key("Type") 5609 objectKey.String(string(v.Type)) 5610 } 5611 5612 if len(v.Visibility) > 0 { 5613 objectKey := object.Key("Visibility") 5614 objectKey.String(string(v.Visibility)) 5615 } 5616 5617 return nil 5618} 5619 5620func awsAwsquery_serializeOpDocumentListTypeVersionsInput(v *ListTypeVersionsInput, value query.Value) error { 5621 object := value.Object() 5622 _ = object 5623 5624 if v.Arn != nil { 5625 objectKey := object.Key("Arn") 5626 objectKey.String(*v.Arn) 5627 } 5628 5629 if len(v.DeprecatedStatus) > 0 { 5630 objectKey := object.Key("DeprecatedStatus") 5631 objectKey.String(string(v.DeprecatedStatus)) 5632 } 5633 5634 if v.MaxResults != nil { 5635 objectKey := object.Key("MaxResults") 5636 objectKey.Integer(*v.MaxResults) 5637 } 5638 5639 if v.NextToken != nil { 5640 objectKey := object.Key("NextToken") 5641 objectKey.String(*v.NextToken) 5642 } 5643 5644 if v.PublisherId != nil { 5645 objectKey := object.Key("PublisherId") 5646 objectKey.String(*v.PublisherId) 5647 } 5648 5649 if len(v.Type) > 0 { 5650 objectKey := object.Key("Type") 5651 objectKey.String(string(v.Type)) 5652 } 5653 5654 if v.TypeName != nil { 5655 objectKey := object.Key("TypeName") 5656 objectKey.String(*v.TypeName) 5657 } 5658 5659 return nil 5660} 5661 5662func awsAwsquery_serializeOpDocumentPublishTypeInput(v *PublishTypeInput, value query.Value) error { 5663 object := value.Object() 5664 _ = object 5665 5666 if v.Arn != nil { 5667 objectKey := object.Key("Arn") 5668 objectKey.String(*v.Arn) 5669 } 5670 5671 if v.PublicVersionNumber != nil { 5672 objectKey := object.Key("PublicVersionNumber") 5673 objectKey.String(*v.PublicVersionNumber) 5674 } 5675 5676 if len(v.Type) > 0 { 5677 objectKey := object.Key("Type") 5678 objectKey.String(string(v.Type)) 5679 } 5680 5681 if v.TypeName != nil { 5682 objectKey := object.Key("TypeName") 5683 objectKey.String(*v.TypeName) 5684 } 5685 5686 return nil 5687} 5688 5689func awsAwsquery_serializeOpDocumentRecordHandlerProgressInput(v *RecordHandlerProgressInput, value query.Value) error { 5690 object := value.Object() 5691 _ = object 5692 5693 if v.BearerToken != nil { 5694 objectKey := object.Key("BearerToken") 5695 objectKey.String(*v.BearerToken) 5696 } 5697 5698 if v.ClientRequestToken != nil { 5699 objectKey := object.Key("ClientRequestToken") 5700 objectKey.String(*v.ClientRequestToken) 5701 } 5702 5703 if len(v.CurrentOperationStatus) > 0 { 5704 objectKey := object.Key("CurrentOperationStatus") 5705 objectKey.String(string(v.CurrentOperationStatus)) 5706 } 5707 5708 if len(v.ErrorCode) > 0 { 5709 objectKey := object.Key("ErrorCode") 5710 objectKey.String(string(v.ErrorCode)) 5711 } 5712 5713 if len(v.OperationStatus) > 0 { 5714 objectKey := object.Key("OperationStatus") 5715 objectKey.String(string(v.OperationStatus)) 5716 } 5717 5718 if v.ResourceModel != nil { 5719 objectKey := object.Key("ResourceModel") 5720 objectKey.String(*v.ResourceModel) 5721 } 5722 5723 if v.StatusMessage != nil { 5724 objectKey := object.Key("StatusMessage") 5725 objectKey.String(*v.StatusMessage) 5726 } 5727 5728 return nil 5729} 5730 5731func awsAwsquery_serializeOpDocumentRegisterPublisherInput(v *RegisterPublisherInput, value query.Value) error { 5732 object := value.Object() 5733 _ = object 5734 5735 if v.AcceptTermsAndConditions != nil { 5736 objectKey := object.Key("AcceptTermsAndConditions") 5737 objectKey.Boolean(*v.AcceptTermsAndConditions) 5738 } 5739 5740 if v.ConnectionArn != nil { 5741 objectKey := object.Key("ConnectionArn") 5742 objectKey.String(*v.ConnectionArn) 5743 } 5744 5745 return nil 5746} 5747 5748func awsAwsquery_serializeOpDocumentRegisterTypeInput(v *RegisterTypeInput, value query.Value) error { 5749 object := value.Object() 5750 _ = object 5751 5752 if v.ClientRequestToken != nil { 5753 objectKey := object.Key("ClientRequestToken") 5754 objectKey.String(*v.ClientRequestToken) 5755 } 5756 5757 if v.ExecutionRoleArn != nil { 5758 objectKey := object.Key("ExecutionRoleArn") 5759 objectKey.String(*v.ExecutionRoleArn) 5760 } 5761 5762 if v.LoggingConfig != nil { 5763 objectKey := object.Key("LoggingConfig") 5764 if err := awsAwsquery_serializeDocumentLoggingConfig(v.LoggingConfig, objectKey); err != nil { 5765 return err 5766 } 5767 } 5768 5769 if v.SchemaHandlerPackage != nil { 5770 objectKey := object.Key("SchemaHandlerPackage") 5771 objectKey.String(*v.SchemaHandlerPackage) 5772 } 5773 5774 if len(v.Type) > 0 { 5775 objectKey := object.Key("Type") 5776 objectKey.String(string(v.Type)) 5777 } 5778 5779 if v.TypeName != nil { 5780 objectKey := object.Key("TypeName") 5781 objectKey.String(*v.TypeName) 5782 } 5783 5784 return nil 5785} 5786 5787func awsAwsquery_serializeOpDocumentRollbackStackInput(v *RollbackStackInput, value query.Value) error { 5788 object := value.Object() 5789 _ = object 5790 5791 if v.ClientRequestToken != nil { 5792 objectKey := object.Key("ClientRequestToken") 5793 objectKey.String(*v.ClientRequestToken) 5794 } 5795 5796 if v.RoleARN != nil { 5797 objectKey := object.Key("RoleARN") 5798 objectKey.String(*v.RoleARN) 5799 } 5800 5801 if v.StackName != nil { 5802 objectKey := object.Key("StackName") 5803 objectKey.String(*v.StackName) 5804 } 5805 5806 return nil 5807} 5808 5809func awsAwsquery_serializeOpDocumentSetStackPolicyInput(v *SetStackPolicyInput, value query.Value) error { 5810 object := value.Object() 5811 _ = object 5812 5813 if v.StackName != nil { 5814 objectKey := object.Key("StackName") 5815 objectKey.String(*v.StackName) 5816 } 5817 5818 if v.StackPolicyBody != nil { 5819 objectKey := object.Key("StackPolicyBody") 5820 objectKey.String(*v.StackPolicyBody) 5821 } 5822 5823 if v.StackPolicyURL != nil { 5824 objectKey := object.Key("StackPolicyURL") 5825 objectKey.String(*v.StackPolicyURL) 5826 } 5827 5828 return nil 5829} 5830 5831func awsAwsquery_serializeOpDocumentSetTypeConfigurationInput(v *SetTypeConfigurationInput, value query.Value) error { 5832 object := value.Object() 5833 _ = object 5834 5835 if v.Configuration != nil { 5836 objectKey := object.Key("Configuration") 5837 objectKey.String(*v.Configuration) 5838 } 5839 5840 if v.ConfigurationAlias != nil { 5841 objectKey := object.Key("ConfigurationAlias") 5842 objectKey.String(*v.ConfigurationAlias) 5843 } 5844 5845 if len(v.Type) > 0 { 5846 objectKey := object.Key("Type") 5847 objectKey.String(string(v.Type)) 5848 } 5849 5850 if v.TypeArn != nil { 5851 objectKey := object.Key("TypeArn") 5852 objectKey.String(*v.TypeArn) 5853 } 5854 5855 if v.TypeName != nil { 5856 objectKey := object.Key("TypeName") 5857 objectKey.String(*v.TypeName) 5858 } 5859 5860 return nil 5861} 5862 5863func awsAwsquery_serializeOpDocumentSetTypeDefaultVersionInput(v *SetTypeDefaultVersionInput, value query.Value) error { 5864 object := value.Object() 5865 _ = object 5866 5867 if v.Arn != nil { 5868 objectKey := object.Key("Arn") 5869 objectKey.String(*v.Arn) 5870 } 5871 5872 if len(v.Type) > 0 { 5873 objectKey := object.Key("Type") 5874 objectKey.String(string(v.Type)) 5875 } 5876 5877 if v.TypeName != nil { 5878 objectKey := object.Key("TypeName") 5879 objectKey.String(*v.TypeName) 5880 } 5881 5882 if v.VersionId != nil { 5883 objectKey := object.Key("VersionId") 5884 objectKey.String(*v.VersionId) 5885 } 5886 5887 return nil 5888} 5889 5890func awsAwsquery_serializeOpDocumentSignalResourceInput(v *SignalResourceInput, value query.Value) error { 5891 object := value.Object() 5892 _ = object 5893 5894 if v.LogicalResourceId != nil { 5895 objectKey := object.Key("LogicalResourceId") 5896 objectKey.String(*v.LogicalResourceId) 5897 } 5898 5899 if v.StackName != nil { 5900 objectKey := object.Key("StackName") 5901 objectKey.String(*v.StackName) 5902 } 5903 5904 if len(v.Status) > 0 { 5905 objectKey := object.Key("Status") 5906 objectKey.String(string(v.Status)) 5907 } 5908 5909 if v.UniqueId != nil { 5910 objectKey := object.Key("UniqueId") 5911 objectKey.String(*v.UniqueId) 5912 } 5913 5914 return nil 5915} 5916 5917func awsAwsquery_serializeOpDocumentStopStackSetOperationInput(v *StopStackSetOperationInput, value query.Value) error { 5918 object := value.Object() 5919 _ = object 5920 5921 if len(v.CallAs) > 0 { 5922 objectKey := object.Key("CallAs") 5923 objectKey.String(string(v.CallAs)) 5924 } 5925 5926 if v.OperationId != nil { 5927 objectKey := object.Key("OperationId") 5928 objectKey.String(*v.OperationId) 5929 } 5930 5931 if v.StackSetName != nil { 5932 objectKey := object.Key("StackSetName") 5933 objectKey.String(*v.StackSetName) 5934 } 5935 5936 return nil 5937} 5938 5939func awsAwsquery_serializeOpDocumentTestTypeInput(v *TestTypeInput, value query.Value) error { 5940 object := value.Object() 5941 _ = object 5942 5943 if v.Arn != nil { 5944 objectKey := object.Key("Arn") 5945 objectKey.String(*v.Arn) 5946 } 5947 5948 if v.LogDeliveryBucket != nil { 5949 objectKey := object.Key("LogDeliveryBucket") 5950 objectKey.String(*v.LogDeliveryBucket) 5951 } 5952 5953 if len(v.Type) > 0 { 5954 objectKey := object.Key("Type") 5955 objectKey.String(string(v.Type)) 5956 } 5957 5958 if v.TypeName != nil { 5959 objectKey := object.Key("TypeName") 5960 objectKey.String(*v.TypeName) 5961 } 5962 5963 if v.VersionId != nil { 5964 objectKey := object.Key("VersionId") 5965 objectKey.String(*v.VersionId) 5966 } 5967 5968 return nil 5969} 5970 5971func awsAwsquery_serializeOpDocumentUpdateStackInput(v *UpdateStackInput, value query.Value) error { 5972 object := value.Object() 5973 _ = object 5974 5975 if v.Capabilities != nil { 5976 objectKey := object.Key("Capabilities") 5977 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 5978 return err 5979 } 5980 } 5981 5982 if v.ClientRequestToken != nil { 5983 objectKey := object.Key("ClientRequestToken") 5984 objectKey.String(*v.ClientRequestToken) 5985 } 5986 5987 if v.DisableRollback != nil { 5988 objectKey := object.Key("DisableRollback") 5989 objectKey.Boolean(*v.DisableRollback) 5990 } 5991 5992 if v.NotificationARNs != nil { 5993 objectKey := object.Key("NotificationARNs") 5994 if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil { 5995 return err 5996 } 5997 } 5998 5999 if v.Parameters != nil { 6000 objectKey := object.Key("Parameters") 6001 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 6002 return err 6003 } 6004 } 6005 6006 if v.ResourceTypes != nil { 6007 objectKey := object.Key("ResourceTypes") 6008 if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil { 6009 return err 6010 } 6011 } 6012 6013 if v.RoleARN != nil { 6014 objectKey := object.Key("RoleARN") 6015 objectKey.String(*v.RoleARN) 6016 } 6017 6018 if v.RollbackConfiguration != nil { 6019 objectKey := object.Key("RollbackConfiguration") 6020 if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil { 6021 return err 6022 } 6023 } 6024 6025 if v.StackName != nil { 6026 objectKey := object.Key("StackName") 6027 objectKey.String(*v.StackName) 6028 } 6029 6030 if v.StackPolicyBody != nil { 6031 objectKey := object.Key("StackPolicyBody") 6032 objectKey.String(*v.StackPolicyBody) 6033 } 6034 6035 if v.StackPolicyDuringUpdateBody != nil { 6036 objectKey := object.Key("StackPolicyDuringUpdateBody") 6037 objectKey.String(*v.StackPolicyDuringUpdateBody) 6038 } 6039 6040 if v.StackPolicyDuringUpdateURL != nil { 6041 objectKey := object.Key("StackPolicyDuringUpdateURL") 6042 objectKey.String(*v.StackPolicyDuringUpdateURL) 6043 } 6044 6045 if v.StackPolicyURL != nil { 6046 objectKey := object.Key("StackPolicyURL") 6047 objectKey.String(*v.StackPolicyURL) 6048 } 6049 6050 if v.Tags != nil { 6051 objectKey := object.Key("Tags") 6052 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 6053 return err 6054 } 6055 } 6056 6057 if v.TemplateBody != nil { 6058 objectKey := object.Key("TemplateBody") 6059 objectKey.String(*v.TemplateBody) 6060 } 6061 6062 if v.TemplateURL != nil { 6063 objectKey := object.Key("TemplateURL") 6064 objectKey.String(*v.TemplateURL) 6065 } 6066 6067 if v.UsePreviousTemplate != nil { 6068 objectKey := object.Key("UsePreviousTemplate") 6069 objectKey.Boolean(*v.UsePreviousTemplate) 6070 } 6071 6072 return nil 6073} 6074 6075func awsAwsquery_serializeOpDocumentUpdateStackInstancesInput(v *UpdateStackInstancesInput, value query.Value) error { 6076 object := value.Object() 6077 _ = object 6078 6079 if v.Accounts != nil { 6080 objectKey := object.Key("Accounts") 6081 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 6082 return err 6083 } 6084 } 6085 6086 if len(v.CallAs) > 0 { 6087 objectKey := object.Key("CallAs") 6088 objectKey.String(string(v.CallAs)) 6089 } 6090 6091 if v.DeploymentTargets != nil { 6092 objectKey := object.Key("DeploymentTargets") 6093 if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil { 6094 return err 6095 } 6096 } 6097 6098 if v.OperationId != nil { 6099 objectKey := object.Key("OperationId") 6100 objectKey.String(*v.OperationId) 6101 } 6102 6103 if v.OperationPreferences != nil { 6104 objectKey := object.Key("OperationPreferences") 6105 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 6106 return err 6107 } 6108 } 6109 6110 if v.ParameterOverrides != nil { 6111 objectKey := object.Key("ParameterOverrides") 6112 if err := awsAwsquery_serializeDocumentParameters(v.ParameterOverrides, objectKey); err != nil { 6113 return err 6114 } 6115 } 6116 6117 if v.Regions != nil { 6118 objectKey := object.Key("Regions") 6119 if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil { 6120 return err 6121 } 6122 } 6123 6124 if v.StackSetName != nil { 6125 objectKey := object.Key("StackSetName") 6126 objectKey.String(*v.StackSetName) 6127 } 6128 6129 return nil 6130} 6131 6132func awsAwsquery_serializeOpDocumentUpdateStackSetInput(v *UpdateStackSetInput, value query.Value) error { 6133 object := value.Object() 6134 _ = object 6135 6136 if v.Accounts != nil { 6137 objectKey := object.Key("Accounts") 6138 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 6139 return err 6140 } 6141 } 6142 6143 if v.AdministrationRoleARN != nil { 6144 objectKey := object.Key("AdministrationRoleARN") 6145 objectKey.String(*v.AdministrationRoleARN) 6146 } 6147 6148 if v.AutoDeployment != nil { 6149 objectKey := object.Key("AutoDeployment") 6150 if err := awsAwsquery_serializeDocumentAutoDeployment(v.AutoDeployment, objectKey); err != nil { 6151 return err 6152 } 6153 } 6154 6155 if len(v.CallAs) > 0 { 6156 objectKey := object.Key("CallAs") 6157 objectKey.String(string(v.CallAs)) 6158 } 6159 6160 if v.Capabilities != nil { 6161 objectKey := object.Key("Capabilities") 6162 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 6163 return err 6164 } 6165 } 6166 6167 if v.DeploymentTargets != nil { 6168 objectKey := object.Key("DeploymentTargets") 6169 if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil { 6170 return err 6171 } 6172 } 6173 6174 if v.Description != nil { 6175 objectKey := object.Key("Description") 6176 objectKey.String(*v.Description) 6177 } 6178 6179 if v.ExecutionRoleName != nil { 6180 objectKey := object.Key("ExecutionRoleName") 6181 objectKey.String(*v.ExecutionRoleName) 6182 } 6183 6184 if v.OperationId != nil { 6185 objectKey := object.Key("OperationId") 6186 objectKey.String(*v.OperationId) 6187 } 6188 6189 if v.OperationPreferences != nil { 6190 objectKey := object.Key("OperationPreferences") 6191 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 6192 return err 6193 } 6194 } 6195 6196 if v.Parameters != nil { 6197 objectKey := object.Key("Parameters") 6198 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 6199 return err 6200 } 6201 } 6202 6203 if len(v.PermissionModel) > 0 { 6204 objectKey := object.Key("PermissionModel") 6205 objectKey.String(string(v.PermissionModel)) 6206 } 6207 6208 if v.Regions != nil { 6209 objectKey := object.Key("Regions") 6210 if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil { 6211 return err 6212 } 6213 } 6214 6215 if v.StackSetName != nil { 6216 objectKey := object.Key("StackSetName") 6217 objectKey.String(*v.StackSetName) 6218 } 6219 6220 if v.Tags != nil { 6221 objectKey := object.Key("Tags") 6222 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 6223 return err 6224 } 6225 } 6226 6227 if v.TemplateBody != nil { 6228 objectKey := object.Key("TemplateBody") 6229 objectKey.String(*v.TemplateBody) 6230 } 6231 6232 if v.TemplateURL != nil { 6233 objectKey := object.Key("TemplateURL") 6234 objectKey.String(*v.TemplateURL) 6235 } 6236 6237 if v.UsePreviousTemplate != nil { 6238 objectKey := object.Key("UsePreviousTemplate") 6239 objectKey.Boolean(*v.UsePreviousTemplate) 6240 } 6241 6242 return nil 6243} 6244 6245func awsAwsquery_serializeOpDocumentUpdateTerminationProtectionInput(v *UpdateTerminationProtectionInput, value query.Value) error { 6246 object := value.Object() 6247 _ = object 6248 6249 if v.EnableTerminationProtection != nil { 6250 objectKey := object.Key("EnableTerminationProtection") 6251 objectKey.Boolean(*v.EnableTerminationProtection) 6252 } 6253 6254 if v.StackName != nil { 6255 objectKey := object.Key("StackName") 6256 objectKey.String(*v.StackName) 6257 } 6258 6259 return nil 6260} 6261 6262func awsAwsquery_serializeOpDocumentValidateTemplateInput(v *ValidateTemplateInput, value query.Value) error { 6263 object := value.Object() 6264 _ = object 6265 6266 if v.TemplateBody != nil { 6267 objectKey := object.Key("TemplateBody") 6268 objectKey.String(*v.TemplateBody) 6269 } 6270 6271 if v.TemplateURL != nil { 6272 objectKey := object.Key("TemplateURL") 6273 objectKey.String(*v.TemplateURL) 6274 } 6275 6276 return nil 6277} 6278