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_serializeOpCancelUpdateStack struct { 19} 20 21func (*awsAwsquery_serializeOpCancelUpdateStack) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsAwsquery_serializeOpCancelUpdateStack) 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.(*CancelUpdateStackInput) 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("CancelUpdateStack") 51 body.Key("Version").String("2010-05-15") 52 53 if err := awsAwsquery_serializeOpDocumentCancelUpdateStackInput(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_serializeOpContinueUpdateRollback struct { 75} 76 77func (*awsAwsquery_serializeOpContinueUpdateRollback) ID() string { 78 return "OperationSerializer" 79} 80 81func (m *awsAwsquery_serializeOpContinueUpdateRollback) 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.(*ContinueUpdateRollbackInput) 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("ContinueUpdateRollback") 107 body.Key("Version").String("2010-05-15") 108 109 if err := awsAwsquery_serializeOpDocumentContinueUpdateRollbackInput(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_serializeOpCreateChangeSet struct { 131} 132 133func (*awsAwsquery_serializeOpCreateChangeSet) ID() string { 134 return "OperationSerializer" 135} 136 137func (m *awsAwsquery_serializeOpCreateChangeSet) 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.(*CreateChangeSetInput) 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("CreateChangeSet") 163 body.Key("Version").String("2010-05-15") 164 165 if err := awsAwsquery_serializeOpDocumentCreateChangeSetInput(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_serializeOpCreateStack struct { 187} 188 189func (*awsAwsquery_serializeOpCreateStack) ID() string { 190 return "OperationSerializer" 191} 192 193func (m *awsAwsquery_serializeOpCreateStack) 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.(*CreateStackInput) 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("CreateStack") 219 body.Key("Version").String("2010-05-15") 220 221 if err := awsAwsquery_serializeOpDocumentCreateStackInput(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_serializeOpCreateStackInstances struct { 243} 244 245func (*awsAwsquery_serializeOpCreateStackInstances) ID() string { 246 return "OperationSerializer" 247} 248 249func (m *awsAwsquery_serializeOpCreateStackInstances) 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.(*CreateStackInstancesInput) 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("CreateStackInstances") 275 body.Key("Version").String("2010-05-15") 276 277 if err := awsAwsquery_serializeOpDocumentCreateStackInstancesInput(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_serializeOpCreateStackSet struct { 299} 300 301func (*awsAwsquery_serializeOpCreateStackSet) ID() string { 302 return "OperationSerializer" 303} 304 305func (m *awsAwsquery_serializeOpCreateStackSet) 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.(*CreateStackSetInput) 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("CreateStackSet") 331 body.Key("Version").String("2010-05-15") 332 333 if err := awsAwsquery_serializeOpDocumentCreateStackSetInput(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_serializeOpDeleteChangeSet struct { 355} 356 357func (*awsAwsquery_serializeOpDeleteChangeSet) ID() string { 358 return "OperationSerializer" 359} 360 361func (m *awsAwsquery_serializeOpDeleteChangeSet) 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.(*DeleteChangeSetInput) 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("DeleteChangeSet") 387 body.Key("Version").String("2010-05-15") 388 389 if err := awsAwsquery_serializeOpDocumentDeleteChangeSetInput(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_serializeOpDeleteStack struct { 411} 412 413func (*awsAwsquery_serializeOpDeleteStack) ID() string { 414 return "OperationSerializer" 415} 416 417func (m *awsAwsquery_serializeOpDeleteStack) 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.(*DeleteStackInput) 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("DeleteStack") 443 body.Key("Version").String("2010-05-15") 444 445 if err := awsAwsquery_serializeOpDocumentDeleteStackInput(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_serializeOpDeleteStackInstances struct { 467} 468 469func (*awsAwsquery_serializeOpDeleteStackInstances) ID() string { 470 return "OperationSerializer" 471} 472 473func (m *awsAwsquery_serializeOpDeleteStackInstances) 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.(*DeleteStackInstancesInput) 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("DeleteStackInstances") 499 body.Key("Version").String("2010-05-15") 500 501 if err := awsAwsquery_serializeOpDocumentDeleteStackInstancesInput(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_serializeOpDeleteStackSet struct { 523} 524 525func (*awsAwsquery_serializeOpDeleteStackSet) ID() string { 526 return "OperationSerializer" 527} 528 529func (m *awsAwsquery_serializeOpDeleteStackSet) 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.(*DeleteStackSetInput) 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("DeleteStackSet") 555 body.Key("Version").String("2010-05-15") 556 557 if err := awsAwsquery_serializeOpDocumentDeleteStackSetInput(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_serializeOpDeregisterType struct { 579} 580 581func (*awsAwsquery_serializeOpDeregisterType) ID() string { 582 return "OperationSerializer" 583} 584 585func (m *awsAwsquery_serializeOpDeregisterType) 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.(*DeregisterTypeInput) 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("DeregisterType") 611 body.Key("Version").String("2010-05-15") 612 613 if err := awsAwsquery_serializeOpDocumentDeregisterTypeInput(input, bodyEncoder.Value); err != nil { 614 return out, metadata, &smithy.SerializationError{Err: err} 615 } 616 617 err = bodyEncoder.Encode() 618 if err != nil { 619 return out, metadata, &smithy.SerializationError{Err: err} 620 } 621 622 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 623 return out, metadata, &smithy.SerializationError{Err: err} 624 } 625 626 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 627 return out, metadata, &smithy.SerializationError{Err: err} 628 } 629 in.Request = request 630 631 return next.HandleSerialize(ctx, in) 632} 633 634type awsAwsquery_serializeOpDescribeAccountLimits struct { 635} 636 637func (*awsAwsquery_serializeOpDescribeAccountLimits) ID() string { 638 return "OperationSerializer" 639} 640 641func (m *awsAwsquery_serializeOpDescribeAccountLimits) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 642 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 643) { 644 request, ok := in.Request.(*smithyhttp.Request) 645 if !ok { 646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 647 } 648 649 input, ok := in.Parameters.(*DescribeAccountLimitsInput) 650 _ = input 651 if !ok { 652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 653 } 654 655 request.Request.URL.Path = "/" 656 request.Request.Method = "POST" 657 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 658 if err != nil { 659 return out, metadata, &smithy.SerializationError{Err: err} 660 } 661 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 662 663 bodyWriter := bytes.NewBuffer(nil) 664 bodyEncoder := query.NewEncoder(bodyWriter) 665 body := bodyEncoder.Object() 666 body.Key("Action").String("DescribeAccountLimits") 667 body.Key("Version").String("2010-05-15") 668 669 if err := awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(input, bodyEncoder.Value); err != nil { 670 return out, metadata, &smithy.SerializationError{Err: err} 671 } 672 673 err = bodyEncoder.Encode() 674 if err != nil { 675 return out, metadata, &smithy.SerializationError{Err: err} 676 } 677 678 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 679 return out, metadata, &smithy.SerializationError{Err: err} 680 } 681 682 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 683 return out, metadata, &smithy.SerializationError{Err: err} 684 } 685 in.Request = request 686 687 return next.HandleSerialize(ctx, in) 688} 689 690type awsAwsquery_serializeOpDescribeChangeSet struct { 691} 692 693func (*awsAwsquery_serializeOpDescribeChangeSet) ID() string { 694 return "OperationSerializer" 695} 696 697func (m *awsAwsquery_serializeOpDescribeChangeSet) 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.(*DescribeChangeSetInput) 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("DescribeChangeSet") 723 body.Key("Version").String("2010-05-15") 724 725 if err := awsAwsquery_serializeOpDocumentDescribeChangeSetInput(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_serializeOpDescribeStackDriftDetectionStatus struct { 747} 748 749func (*awsAwsquery_serializeOpDescribeStackDriftDetectionStatus) ID() string { 750 return "OperationSerializer" 751} 752 753func (m *awsAwsquery_serializeOpDescribeStackDriftDetectionStatus) 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.(*DescribeStackDriftDetectionStatusInput) 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("DescribeStackDriftDetectionStatus") 779 body.Key("Version").String("2010-05-15") 780 781 if err := awsAwsquery_serializeOpDocumentDescribeStackDriftDetectionStatusInput(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_serializeOpDescribeStackEvents struct { 803} 804 805func (*awsAwsquery_serializeOpDescribeStackEvents) ID() string { 806 return "OperationSerializer" 807} 808 809func (m *awsAwsquery_serializeOpDescribeStackEvents) 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.(*DescribeStackEventsInput) 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("DescribeStackEvents") 835 body.Key("Version").String("2010-05-15") 836 837 if err := awsAwsquery_serializeOpDocumentDescribeStackEventsInput(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_serializeOpDescribeStackInstance struct { 859} 860 861func (*awsAwsquery_serializeOpDescribeStackInstance) ID() string { 862 return "OperationSerializer" 863} 864 865func (m *awsAwsquery_serializeOpDescribeStackInstance) 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.(*DescribeStackInstanceInput) 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("DescribeStackInstance") 891 body.Key("Version").String("2010-05-15") 892 893 if err := awsAwsquery_serializeOpDocumentDescribeStackInstanceInput(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_serializeOpDescribeStackResource struct { 915} 916 917func (*awsAwsquery_serializeOpDescribeStackResource) ID() string { 918 return "OperationSerializer" 919} 920 921func (m *awsAwsquery_serializeOpDescribeStackResource) 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.(*DescribeStackResourceInput) 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("DescribeStackResource") 947 body.Key("Version").String("2010-05-15") 948 949 if err := awsAwsquery_serializeOpDocumentDescribeStackResourceInput(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_serializeOpDescribeStackResourceDrifts struct { 971} 972 973func (*awsAwsquery_serializeOpDescribeStackResourceDrifts) ID() string { 974 return "OperationSerializer" 975} 976 977func (m *awsAwsquery_serializeOpDescribeStackResourceDrifts) 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.(*DescribeStackResourceDriftsInput) 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("DescribeStackResourceDrifts") 1003 body.Key("Version").String("2010-05-15") 1004 1005 if err := awsAwsquery_serializeOpDocumentDescribeStackResourceDriftsInput(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_serializeOpDescribeStackResources struct { 1027} 1028 1029func (*awsAwsquery_serializeOpDescribeStackResources) ID() string { 1030 return "OperationSerializer" 1031} 1032 1033func (m *awsAwsquery_serializeOpDescribeStackResources) 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.(*DescribeStackResourcesInput) 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("DescribeStackResources") 1059 body.Key("Version").String("2010-05-15") 1060 1061 if err := awsAwsquery_serializeOpDocumentDescribeStackResourcesInput(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_serializeOpDescribeStacks struct { 1083} 1084 1085func (*awsAwsquery_serializeOpDescribeStacks) ID() string { 1086 return "OperationSerializer" 1087} 1088 1089func (m *awsAwsquery_serializeOpDescribeStacks) 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.(*DescribeStacksInput) 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("DescribeStacks") 1115 body.Key("Version").String("2010-05-15") 1116 1117 if err := awsAwsquery_serializeOpDocumentDescribeStacksInput(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_serializeOpDescribeStackSet struct { 1139} 1140 1141func (*awsAwsquery_serializeOpDescribeStackSet) ID() string { 1142 return "OperationSerializer" 1143} 1144 1145func (m *awsAwsquery_serializeOpDescribeStackSet) 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.(*DescribeStackSetInput) 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("DescribeStackSet") 1171 body.Key("Version").String("2010-05-15") 1172 1173 if err := awsAwsquery_serializeOpDocumentDescribeStackSetInput(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_serializeOpDescribeStackSetOperation struct { 1195} 1196 1197func (*awsAwsquery_serializeOpDescribeStackSetOperation) ID() string { 1198 return "OperationSerializer" 1199} 1200 1201func (m *awsAwsquery_serializeOpDescribeStackSetOperation) 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.(*DescribeStackSetOperationInput) 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("DescribeStackSetOperation") 1227 body.Key("Version").String("2010-05-15") 1228 1229 if err := awsAwsquery_serializeOpDocumentDescribeStackSetOperationInput(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_serializeOpDescribeType struct { 1251} 1252 1253func (*awsAwsquery_serializeOpDescribeType) ID() string { 1254 return "OperationSerializer" 1255} 1256 1257func (m *awsAwsquery_serializeOpDescribeType) 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.(*DescribeTypeInput) 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("DescribeType") 1283 body.Key("Version").String("2010-05-15") 1284 1285 if err := awsAwsquery_serializeOpDocumentDescribeTypeInput(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_serializeOpDescribeTypeRegistration struct { 1307} 1308 1309func (*awsAwsquery_serializeOpDescribeTypeRegistration) ID() string { 1310 return "OperationSerializer" 1311} 1312 1313func (m *awsAwsquery_serializeOpDescribeTypeRegistration) 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.(*DescribeTypeRegistrationInput) 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("DescribeTypeRegistration") 1339 body.Key("Version").String("2010-05-15") 1340 1341 if err := awsAwsquery_serializeOpDocumentDescribeTypeRegistrationInput(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_serializeOpDetectStackDrift struct { 1363} 1364 1365func (*awsAwsquery_serializeOpDetectStackDrift) ID() string { 1366 return "OperationSerializer" 1367} 1368 1369func (m *awsAwsquery_serializeOpDetectStackDrift) 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.(*DetectStackDriftInput) 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("DetectStackDrift") 1395 body.Key("Version").String("2010-05-15") 1396 1397 if err := awsAwsquery_serializeOpDocumentDetectStackDriftInput(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_serializeOpDetectStackResourceDrift struct { 1419} 1420 1421func (*awsAwsquery_serializeOpDetectStackResourceDrift) ID() string { 1422 return "OperationSerializer" 1423} 1424 1425func (m *awsAwsquery_serializeOpDetectStackResourceDrift) 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.(*DetectStackResourceDriftInput) 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("DetectStackResourceDrift") 1451 body.Key("Version").String("2010-05-15") 1452 1453 if err := awsAwsquery_serializeOpDocumentDetectStackResourceDriftInput(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_serializeOpDetectStackSetDrift struct { 1475} 1476 1477func (*awsAwsquery_serializeOpDetectStackSetDrift) ID() string { 1478 return "OperationSerializer" 1479} 1480 1481func (m *awsAwsquery_serializeOpDetectStackSetDrift) 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.(*DetectStackSetDriftInput) 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("DetectStackSetDrift") 1507 body.Key("Version").String("2010-05-15") 1508 1509 if err := awsAwsquery_serializeOpDocumentDetectStackSetDriftInput(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_serializeOpEstimateTemplateCost struct { 1531} 1532 1533func (*awsAwsquery_serializeOpEstimateTemplateCost) ID() string { 1534 return "OperationSerializer" 1535} 1536 1537func (m *awsAwsquery_serializeOpEstimateTemplateCost) 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.(*EstimateTemplateCostInput) 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("EstimateTemplateCost") 1563 body.Key("Version").String("2010-05-15") 1564 1565 if err := awsAwsquery_serializeOpDocumentEstimateTemplateCostInput(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_serializeOpExecuteChangeSet struct { 1587} 1588 1589func (*awsAwsquery_serializeOpExecuteChangeSet) ID() string { 1590 return "OperationSerializer" 1591} 1592 1593func (m *awsAwsquery_serializeOpExecuteChangeSet) 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.(*ExecuteChangeSetInput) 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("ExecuteChangeSet") 1619 body.Key("Version").String("2010-05-15") 1620 1621 if err := awsAwsquery_serializeOpDocumentExecuteChangeSetInput(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_serializeOpGetStackPolicy struct { 1643} 1644 1645func (*awsAwsquery_serializeOpGetStackPolicy) ID() string { 1646 return "OperationSerializer" 1647} 1648 1649func (m *awsAwsquery_serializeOpGetStackPolicy) 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.(*GetStackPolicyInput) 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("GetStackPolicy") 1675 body.Key("Version").String("2010-05-15") 1676 1677 if err := awsAwsquery_serializeOpDocumentGetStackPolicyInput(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_serializeOpGetTemplate struct { 1699} 1700 1701func (*awsAwsquery_serializeOpGetTemplate) ID() string { 1702 return "OperationSerializer" 1703} 1704 1705func (m *awsAwsquery_serializeOpGetTemplate) 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.(*GetTemplateInput) 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("GetTemplate") 1731 body.Key("Version").String("2010-05-15") 1732 1733 if err := awsAwsquery_serializeOpDocumentGetTemplateInput(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_serializeOpGetTemplateSummary struct { 1755} 1756 1757func (*awsAwsquery_serializeOpGetTemplateSummary) ID() string { 1758 return "OperationSerializer" 1759} 1760 1761func (m *awsAwsquery_serializeOpGetTemplateSummary) 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.(*GetTemplateSummaryInput) 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("GetTemplateSummary") 1787 body.Key("Version").String("2010-05-15") 1788 1789 if err := awsAwsquery_serializeOpDocumentGetTemplateSummaryInput(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_serializeOpListChangeSets struct { 1811} 1812 1813func (*awsAwsquery_serializeOpListChangeSets) ID() string { 1814 return "OperationSerializer" 1815} 1816 1817func (m *awsAwsquery_serializeOpListChangeSets) 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.(*ListChangeSetsInput) 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("ListChangeSets") 1843 body.Key("Version").String("2010-05-15") 1844 1845 if err := awsAwsquery_serializeOpDocumentListChangeSetsInput(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_serializeOpListExports struct { 1867} 1868 1869func (*awsAwsquery_serializeOpListExports) ID() string { 1870 return "OperationSerializer" 1871} 1872 1873func (m *awsAwsquery_serializeOpListExports) 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.(*ListExportsInput) 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("ListExports") 1899 body.Key("Version").String("2010-05-15") 1900 1901 if err := awsAwsquery_serializeOpDocumentListExportsInput(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_serializeOpListImports struct { 1923} 1924 1925func (*awsAwsquery_serializeOpListImports) ID() string { 1926 return "OperationSerializer" 1927} 1928 1929func (m *awsAwsquery_serializeOpListImports) 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.(*ListImportsInput) 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("ListImports") 1955 body.Key("Version").String("2010-05-15") 1956 1957 if err := awsAwsquery_serializeOpDocumentListImportsInput(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_serializeOpListStackInstances struct { 1979} 1980 1981func (*awsAwsquery_serializeOpListStackInstances) ID() string { 1982 return "OperationSerializer" 1983} 1984 1985func (m *awsAwsquery_serializeOpListStackInstances) 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.(*ListStackInstancesInput) 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("ListStackInstances") 2011 body.Key("Version").String("2010-05-15") 2012 2013 if err := awsAwsquery_serializeOpDocumentListStackInstancesInput(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_serializeOpListStackResources struct { 2035} 2036 2037func (*awsAwsquery_serializeOpListStackResources) ID() string { 2038 return "OperationSerializer" 2039} 2040 2041func (m *awsAwsquery_serializeOpListStackResources) 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.(*ListStackResourcesInput) 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("ListStackResources") 2067 body.Key("Version").String("2010-05-15") 2068 2069 if err := awsAwsquery_serializeOpDocumentListStackResourcesInput(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_serializeOpListStacks struct { 2091} 2092 2093func (*awsAwsquery_serializeOpListStacks) ID() string { 2094 return "OperationSerializer" 2095} 2096 2097func (m *awsAwsquery_serializeOpListStacks) 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.(*ListStacksInput) 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("ListStacks") 2123 body.Key("Version").String("2010-05-15") 2124 2125 if err := awsAwsquery_serializeOpDocumentListStacksInput(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_serializeOpListStackSetOperationResults struct { 2147} 2148 2149func (*awsAwsquery_serializeOpListStackSetOperationResults) ID() string { 2150 return "OperationSerializer" 2151} 2152 2153func (m *awsAwsquery_serializeOpListStackSetOperationResults) 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.(*ListStackSetOperationResultsInput) 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("ListStackSetOperationResults") 2179 body.Key("Version").String("2010-05-15") 2180 2181 if err := awsAwsquery_serializeOpDocumentListStackSetOperationResultsInput(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_serializeOpListStackSetOperations struct { 2203} 2204 2205func (*awsAwsquery_serializeOpListStackSetOperations) ID() string { 2206 return "OperationSerializer" 2207} 2208 2209func (m *awsAwsquery_serializeOpListStackSetOperations) 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.(*ListStackSetOperationsInput) 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("ListStackSetOperations") 2235 body.Key("Version").String("2010-05-15") 2236 2237 if err := awsAwsquery_serializeOpDocumentListStackSetOperationsInput(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_serializeOpListStackSets struct { 2259} 2260 2261func (*awsAwsquery_serializeOpListStackSets) ID() string { 2262 return "OperationSerializer" 2263} 2264 2265func (m *awsAwsquery_serializeOpListStackSets) 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.(*ListStackSetsInput) 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("ListStackSets") 2291 body.Key("Version").String("2010-05-15") 2292 2293 if err := awsAwsquery_serializeOpDocumentListStackSetsInput(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_serializeOpListTypeRegistrations struct { 2315} 2316 2317func (*awsAwsquery_serializeOpListTypeRegistrations) ID() string { 2318 return "OperationSerializer" 2319} 2320 2321func (m *awsAwsquery_serializeOpListTypeRegistrations) 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.(*ListTypeRegistrationsInput) 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("ListTypeRegistrations") 2347 body.Key("Version").String("2010-05-15") 2348 2349 if err := awsAwsquery_serializeOpDocumentListTypeRegistrationsInput(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_serializeOpListTypes struct { 2371} 2372 2373func (*awsAwsquery_serializeOpListTypes) ID() string { 2374 return "OperationSerializer" 2375} 2376 2377func (m *awsAwsquery_serializeOpListTypes) 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.(*ListTypesInput) 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("ListTypes") 2403 body.Key("Version").String("2010-05-15") 2404 2405 if err := awsAwsquery_serializeOpDocumentListTypesInput(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_serializeOpListTypeVersions struct { 2427} 2428 2429func (*awsAwsquery_serializeOpListTypeVersions) ID() string { 2430 return "OperationSerializer" 2431} 2432 2433func (m *awsAwsquery_serializeOpListTypeVersions) 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.(*ListTypeVersionsInput) 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("ListTypeVersions") 2459 body.Key("Version").String("2010-05-15") 2460 2461 if err := awsAwsquery_serializeOpDocumentListTypeVersionsInput(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_serializeOpRecordHandlerProgress struct { 2483} 2484 2485func (*awsAwsquery_serializeOpRecordHandlerProgress) ID() string { 2486 return "OperationSerializer" 2487} 2488 2489func (m *awsAwsquery_serializeOpRecordHandlerProgress) 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.(*RecordHandlerProgressInput) 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("RecordHandlerProgress") 2515 body.Key("Version").String("2010-05-15") 2516 2517 if err := awsAwsquery_serializeOpDocumentRecordHandlerProgressInput(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_serializeOpRegisterType struct { 2539} 2540 2541func (*awsAwsquery_serializeOpRegisterType) ID() string { 2542 return "OperationSerializer" 2543} 2544 2545func (m *awsAwsquery_serializeOpRegisterType) 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.(*RegisterTypeInput) 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("RegisterType") 2571 body.Key("Version").String("2010-05-15") 2572 2573 if err := awsAwsquery_serializeOpDocumentRegisterTypeInput(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_serializeOpSetStackPolicy struct { 2595} 2596 2597func (*awsAwsquery_serializeOpSetStackPolicy) ID() string { 2598 return "OperationSerializer" 2599} 2600 2601func (m *awsAwsquery_serializeOpSetStackPolicy) 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.(*SetStackPolicyInput) 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("SetStackPolicy") 2627 body.Key("Version").String("2010-05-15") 2628 2629 if err := awsAwsquery_serializeOpDocumentSetStackPolicyInput(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_serializeOpSetTypeDefaultVersion struct { 2651} 2652 2653func (*awsAwsquery_serializeOpSetTypeDefaultVersion) ID() string { 2654 return "OperationSerializer" 2655} 2656 2657func (m *awsAwsquery_serializeOpSetTypeDefaultVersion) 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.(*SetTypeDefaultVersionInput) 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("SetTypeDefaultVersion") 2683 body.Key("Version").String("2010-05-15") 2684 2685 if err := awsAwsquery_serializeOpDocumentSetTypeDefaultVersionInput(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_serializeOpSignalResource struct { 2707} 2708 2709func (*awsAwsquery_serializeOpSignalResource) ID() string { 2710 return "OperationSerializer" 2711} 2712 2713func (m *awsAwsquery_serializeOpSignalResource) 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.(*SignalResourceInput) 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("SignalResource") 2739 body.Key("Version").String("2010-05-15") 2740 2741 if err := awsAwsquery_serializeOpDocumentSignalResourceInput(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_serializeOpStopStackSetOperation struct { 2763} 2764 2765func (*awsAwsquery_serializeOpStopStackSetOperation) ID() string { 2766 return "OperationSerializer" 2767} 2768 2769func (m *awsAwsquery_serializeOpStopStackSetOperation) 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.(*StopStackSetOperationInput) 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("StopStackSetOperation") 2795 body.Key("Version").String("2010-05-15") 2796 2797 if err := awsAwsquery_serializeOpDocumentStopStackSetOperationInput(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_serializeOpUpdateStack struct { 2819} 2820 2821func (*awsAwsquery_serializeOpUpdateStack) ID() string { 2822 return "OperationSerializer" 2823} 2824 2825func (m *awsAwsquery_serializeOpUpdateStack) 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.(*UpdateStackInput) 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("UpdateStack") 2851 body.Key("Version").String("2010-05-15") 2852 2853 if err := awsAwsquery_serializeOpDocumentUpdateStackInput(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_serializeOpUpdateStackInstances struct { 2875} 2876 2877func (*awsAwsquery_serializeOpUpdateStackInstances) ID() string { 2878 return "OperationSerializer" 2879} 2880 2881func (m *awsAwsquery_serializeOpUpdateStackInstances) 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.(*UpdateStackInstancesInput) 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("UpdateStackInstances") 2907 body.Key("Version").String("2010-05-15") 2908 2909 if err := awsAwsquery_serializeOpDocumentUpdateStackInstancesInput(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_serializeOpUpdateStackSet struct { 2931} 2932 2933func (*awsAwsquery_serializeOpUpdateStackSet) ID() string { 2934 return "OperationSerializer" 2935} 2936 2937func (m *awsAwsquery_serializeOpUpdateStackSet) 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.(*UpdateStackSetInput) 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("UpdateStackSet") 2963 body.Key("Version").String("2010-05-15") 2964 2965 if err := awsAwsquery_serializeOpDocumentUpdateStackSetInput(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_serializeOpUpdateTerminationProtection struct { 2987} 2988 2989func (*awsAwsquery_serializeOpUpdateTerminationProtection) ID() string { 2990 return "OperationSerializer" 2991} 2992 2993func (m *awsAwsquery_serializeOpUpdateTerminationProtection) 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.(*UpdateTerminationProtectionInput) 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("UpdateTerminationProtection") 3019 body.Key("Version").String("2010-05-15") 3020 3021 if err := awsAwsquery_serializeOpDocumentUpdateTerminationProtectionInput(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_serializeOpValidateTemplate struct { 3043} 3044 3045func (*awsAwsquery_serializeOpValidateTemplate) ID() string { 3046 return "OperationSerializer" 3047} 3048 3049func (m *awsAwsquery_serializeOpValidateTemplate) 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.(*ValidateTemplateInput) 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("ValidateTemplate") 3075 body.Key("Version").String("2010-05-15") 3076 3077 if err := awsAwsquery_serializeOpDocumentValidateTemplateInput(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} 3097func awsAwsquery_serializeDocumentAccountList(v []string, value query.Value) error { 3098 if len(v) == 0 { 3099 return nil 3100 } 3101 array := value.Array("member") 3102 3103 for i := range v { 3104 av := array.Value() 3105 av.String(v[i]) 3106 } 3107 return nil 3108} 3109 3110func awsAwsquery_serializeDocumentAutoDeployment(v *types.AutoDeployment, value query.Value) error { 3111 object := value.Object() 3112 _ = object 3113 3114 if v.Enabled != nil { 3115 objectKey := object.Key("Enabled") 3116 objectKey.Boolean(*v.Enabled) 3117 } 3118 3119 if v.RetainStacksOnAccountRemoval != nil { 3120 objectKey := object.Key("RetainStacksOnAccountRemoval") 3121 objectKey.Boolean(*v.RetainStacksOnAccountRemoval) 3122 } 3123 3124 return nil 3125} 3126 3127func awsAwsquery_serializeDocumentCapabilities(v []types.Capability, value query.Value) error { 3128 if len(v) == 0 { 3129 return nil 3130 } 3131 array := value.Array("member") 3132 3133 for i := range v { 3134 av := array.Value() 3135 av.String(string(v[i])) 3136 } 3137 return nil 3138} 3139 3140func awsAwsquery_serializeDocumentDeploymentTargets(v *types.DeploymentTargets, value query.Value) error { 3141 object := value.Object() 3142 _ = object 3143 3144 if v.Accounts != nil { 3145 objectKey := object.Key("Accounts") 3146 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 3147 return err 3148 } 3149 } 3150 3151 if v.AccountsUrl != nil { 3152 objectKey := object.Key("AccountsUrl") 3153 objectKey.String(*v.AccountsUrl) 3154 } 3155 3156 if v.OrganizationalUnitIds != nil { 3157 objectKey := object.Key("OrganizationalUnitIds") 3158 if err := awsAwsquery_serializeDocumentOrganizationalUnitIdList(v.OrganizationalUnitIds, objectKey); err != nil { 3159 return err 3160 } 3161 } 3162 3163 return nil 3164} 3165 3166func awsAwsquery_serializeDocumentLoggingConfig(v *types.LoggingConfig, value query.Value) error { 3167 object := value.Object() 3168 _ = object 3169 3170 if v.LogGroupName != nil { 3171 objectKey := object.Key("LogGroupName") 3172 objectKey.String(*v.LogGroupName) 3173 } 3174 3175 if v.LogRoleArn != nil { 3176 objectKey := object.Key("LogRoleArn") 3177 objectKey.String(*v.LogRoleArn) 3178 } 3179 3180 return nil 3181} 3182 3183func awsAwsquery_serializeDocumentLogicalResourceIds(v []string, value query.Value) error { 3184 if len(v) == 0 { 3185 return nil 3186 } 3187 array := value.Array("member") 3188 3189 for i := range v { 3190 av := array.Value() 3191 av.String(v[i]) 3192 } 3193 return nil 3194} 3195 3196func awsAwsquery_serializeDocumentNotificationARNs(v []string, value query.Value) error { 3197 if len(v) == 0 { 3198 return nil 3199 } 3200 array := value.Array("member") 3201 3202 for i := range v { 3203 av := array.Value() 3204 av.String(v[i]) 3205 } 3206 return nil 3207} 3208 3209func awsAwsquery_serializeDocumentOrganizationalUnitIdList(v []string, value query.Value) error { 3210 if len(v) == 0 { 3211 return nil 3212 } 3213 array := value.Array("member") 3214 3215 for i := range v { 3216 av := array.Value() 3217 av.String(v[i]) 3218 } 3219 return nil 3220} 3221 3222func awsAwsquery_serializeDocumentParameter(v *types.Parameter, value query.Value) error { 3223 object := value.Object() 3224 _ = object 3225 3226 if v.ParameterKey != nil { 3227 objectKey := object.Key("ParameterKey") 3228 objectKey.String(*v.ParameterKey) 3229 } 3230 3231 if v.ParameterValue != nil { 3232 objectKey := object.Key("ParameterValue") 3233 objectKey.String(*v.ParameterValue) 3234 } 3235 3236 if v.ResolvedValue != nil { 3237 objectKey := object.Key("ResolvedValue") 3238 objectKey.String(*v.ResolvedValue) 3239 } 3240 3241 if v.UsePreviousValue != nil { 3242 objectKey := object.Key("UsePreviousValue") 3243 objectKey.Boolean(*v.UsePreviousValue) 3244 } 3245 3246 return nil 3247} 3248 3249func awsAwsquery_serializeDocumentParameters(v []types.Parameter, value query.Value) error { 3250 if len(v) == 0 { 3251 return nil 3252 } 3253 array := value.Array("member") 3254 3255 for i := range v { 3256 av := array.Value() 3257 if err := awsAwsquery_serializeDocumentParameter(&v[i], av); err != nil { 3258 return err 3259 } 3260 } 3261 return nil 3262} 3263 3264func awsAwsquery_serializeDocumentRegionList(v []string, value query.Value) error { 3265 if len(v) == 0 { 3266 return nil 3267 } 3268 array := value.Array("member") 3269 3270 for i := range v { 3271 av := array.Value() 3272 av.String(v[i]) 3273 } 3274 return nil 3275} 3276 3277func awsAwsquery_serializeDocumentResourceIdentifierProperties(v map[string]string, value query.Value) error { 3278 if len(v) == 0 { 3279 return nil 3280 } 3281 object := value.Map("key", "value") 3282 3283 keys := make([]string, 0, len(v)) 3284 for key := range v { 3285 keys = append(keys, key) 3286 } 3287 sort.Strings(keys) 3288 3289 for _, key := range keys { 3290 om := object.Key(key) 3291 om.String(v[key]) 3292 } 3293 return nil 3294} 3295 3296func awsAwsquery_serializeDocumentResourcesToImport(v []types.ResourceToImport, value query.Value) error { 3297 if len(v) == 0 { 3298 return nil 3299 } 3300 array := value.Array("member") 3301 3302 for i := range v { 3303 av := array.Value() 3304 if err := awsAwsquery_serializeDocumentResourceToImport(&v[i], av); err != nil { 3305 return err 3306 } 3307 } 3308 return nil 3309} 3310 3311func awsAwsquery_serializeDocumentResourcesToSkip(v []string, value query.Value) error { 3312 if len(v) == 0 { 3313 return nil 3314 } 3315 array := value.Array("member") 3316 3317 for i := range v { 3318 av := array.Value() 3319 av.String(v[i]) 3320 } 3321 return nil 3322} 3323 3324func awsAwsquery_serializeDocumentResourceToImport(v *types.ResourceToImport, value query.Value) error { 3325 object := value.Object() 3326 _ = object 3327 3328 if v.LogicalResourceId != nil { 3329 objectKey := object.Key("LogicalResourceId") 3330 objectKey.String(*v.LogicalResourceId) 3331 } 3332 3333 if v.ResourceIdentifier != nil { 3334 objectKey := object.Key("ResourceIdentifier") 3335 if err := awsAwsquery_serializeDocumentResourceIdentifierProperties(v.ResourceIdentifier, objectKey); err != nil { 3336 return err 3337 } 3338 } 3339 3340 if v.ResourceType != nil { 3341 objectKey := object.Key("ResourceType") 3342 objectKey.String(*v.ResourceType) 3343 } 3344 3345 return nil 3346} 3347 3348func awsAwsquery_serializeDocumentResourceTypes(v []string, value query.Value) error { 3349 if len(v) == 0 { 3350 return nil 3351 } 3352 array := value.Array("member") 3353 3354 for i := range v { 3355 av := array.Value() 3356 av.String(v[i]) 3357 } 3358 return nil 3359} 3360 3361func awsAwsquery_serializeDocumentRetainResources(v []string, value query.Value) error { 3362 if len(v) == 0 { 3363 return nil 3364 } 3365 array := value.Array("member") 3366 3367 for i := range v { 3368 av := array.Value() 3369 av.String(v[i]) 3370 } 3371 return nil 3372} 3373 3374func awsAwsquery_serializeDocumentRollbackConfiguration(v *types.RollbackConfiguration, value query.Value) error { 3375 object := value.Object() 3376 _ = object 3377 3378 if v.MonitoringTimeInMinutes != nil { 3379 objectKey := object.Key("MonitoringTimeInMinutes") 3380 objectKey.Integer(*v.MonitoringTimeInMinutes) 3381 } 3382 3383 if v.RollbackTriggers != nil { 3384 objectKey := object.Key("RollbackTriggers") 3385 if err := awsAwsquery_serializeDocumentRollbackTriggers(v.RollbackTriggers, objectKey); err != nil { 3386 return err 3387 } 3388 } 3389 3390 return nil 3391} 3392 3393func awsAwsquery_serializeDocumentRollbackTrigger(v *types.RollbackTrigger, value query.Value) error { 3394 object := value.Object() 3395 _ = object 3396 3397 if v.Arn != nil { 3398 objectKey := object.Key("Arn") 3399 objectKey.String(*v.Arn) 3400 } 3401 3402 if v.Type != nil { 3403 objectKey := object.Key("Type") 3404 objectKey.String(*v.Type) 3405 } 3406 3407 return nil 3408} 3409 3410func awsAwsquery_serializeDocumentRollbackTriggers(v []types.RollbackTrigger, value query.Value) error { 3411 if len(v) == 0 { 3412 return nil 3413 } 3414 array := value.Array("member") 3415 3416 for i := range v { 3417 av := array.Value() 3418 if err := awsAwsquery_serializeDocumentRollbackTrigger(&v[i], av); err != nil { 3419 return err 3420 } 3421 } 3422 return nil 3423} 3424 3425func awsAwsquery_serializeDocumentStackInstanceFilter(v *types.StackInstanceFilter, value query.Value) error { 3426 object := value.Object() 3427 _ = object 3428 3429 if len(v.Name) > 0 { 3430 objectKey := object.Key("Name") 3431 objectKey.String(string(v.Name)) 3432 } 3433 3434 if v.Values != nil { 3435 objectKey := object.Key("Values") 3436 objectKey.String(*v.Values) 3437 } 3438 3439 return nil 3440} 3441 3442func awsAwsquery_serializeDocumentStackInstanceFilters(v []types.StackInstanceFilter, value query.Value) error { 3443 if len(v) == 0 { 3444 return nil 3445 } 3446 array := value.Array("member") 3447 3448 for i := range v { 3449 av := array.Value() 3450 if err := awsAwsquery_serializeDocumentStackInstanceFilter(&v[i], av); err != nil { 3451 return err 3452 } 3453 } 3454 return nil 3455} 3456 3457func awsAwsquery_serializeDocumentStackResourceDriftStatusFilters(v []types.StackResourceDriftStatus, value query.Value) error { 3458 if len(v) == 0 { 3459 return nil 3460 } 3461 array := value.Array("member") 3462 3463 for i := range v { 3464 av := array.Value() 3465 av.String(string(v[i])) 3466 } 3467 return nil 3468} 3469 3470func awsAwsquery_serializeDocumentStackSetOperationPreferences(v *types.StackSetOperationPreferences, value query.Value) error { 3471 object := value.Object() 3472 _ = object 3473 3474 if v.FailureToleranceCount != nil { 3475 objectKey := object.Key("FailureToleranceCount") 3476 objectKey.Integer(*v.FailureToleranceCount) 3477 } 3478 3479 if v.FailureTolerancePercentage != nil { 3480 objectKey := object.Key("FailureTolerancePercentage") 3481 objectKey.Integer(*v.FailureTolerancePercentage) 3482 } 3483 3484 if v.MaxConcurrentCount != nil { 3485 objectKey := object.Key("MaxConcurrentCount") 3486 objectKey.Integer(*v.MaxConcurrentCount) 3487 } 3488 3489 if v.MaxConcurrentPercentage != nil { 3490 objectKey := object.Key("MaxConcurrentPercentage") 3491 objectKey.Integer(*v.MaxConcurrentPercentage) 3492 } 3493 3494 if len(v.RegionConcurrencyType) > 0 { 3495 objectKey := object.Key("RegionConcurrencyType") 3496 objectKey.String(string(v.RegionConcurrencyType)) 3497 } 3498 3499 if v.RegionOrder != nil { 3500 objectKey := object.Key("RegionOrder") 3501 if err := awsAwsquery_serializeDocumentRegionList(v.RegionOrder, objectKey); err != nil { 3502 return err 3503 } 3504 } 3505 3506 return nil 3507} 3508 3509func awsAwsquery_serializeDocumentStackStatusFilter(v []types.StackStatus, value query.Value) error { 3510 if len(v) == 0 { 3511 return nil 3512 } 3513 array := value.Array("member") 3514 3515 for i := range v { 3516 av := array.Value() 3517 av.String(string(v[i])) 3518 } 3519 return nil 3520} 3521 3522func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error { 3523 object := value.Object() 3524 _ = object 3525 3526 if v.Key != nil { 3527 objectKey := object.Key("Key") 3528 objectKey.String(*v.Key) 3529 } 3530 3531 if v.Value != nil { 3532 objectKey := object.Key("Value") 3533 objectKey.String(*v.Value) 3534 } 3535 3536 return nil 3537} 3538 3539func awsAwsquery_serializeDocumentTags(v []types.Tag, value query.Value) error { 3540 if len(v) == 0 { 3541 return nil 3542 } 3543 array := value.Array("member") 3544 3545 for i := range v { 3546 av := array.Value() 3547 if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil { 3548 return err 3549 } 3550 } 3551 return nil 3552} 3553 3554func awsAwsquery_serializeOpDocumentCancelUpdateStackInput(v *CancelUpdateStackInput, value query.Value) error { 3555 object := value.Object() 3556 _ = object 3557 3558 if v.ClientRequestToken != nil { 3559 objectKey := object.Key("ClientRequestToken") 3560 objectKey.String(*v.ClientRequestToken) 3561 } 3562 3563 if v.StackName != nil { 3564 objectKey := object.Key("StackName") 3565 objectKey.String(*v.StackName) 3566 } 3567 3568 return nil 3569} 3570 3571func awsAwsquery_serializeOpDocumentContinueUpdateRollbackInput(v *ContinueUpdateRollbackInput, value query.Value) error { 3572 object := value.Object() 3573 _ = object 3574 3575 if v.ClientRequestToken != nil { 3576 objectKey := object.Key("ClientRequestToken") 3577 objectKey.String(*v.ClientRequestToken) 3578 } 3579 3580 if v.ResourcesToSkip != nil { 3581 objectKey := object.Key("ResourcesToSkip") 3582 if err := awsAwsquery_serializeDocumentResourcesToSkip(v.ResourcesToSkip, objectKey); err != nil { 3583 return err 3584 } 3585 } 3586 3587 if v.RoleARN != nil { 3588 objectKey := object.Key("RoleARN") 3589 objectKey.String(*v.RoleARN) 3590 } 3591 3592 if v.StackName != nil { 3593 objectKey := object.Key("StackName") 3594 objectKey.String(*v.StackName) 3595 } 3596 3597 return nil 3598} 3599 3600func awsAwsquery_serializeOpDocumentCreateChangeSetInput(v *CreateChangeSetInput, value query.Value) error { 3601 object := value.Object() 3602 _ = object 3603 3604 if v.Capabilities != nil { 3605 objectKey := object.Key("Capabilities") 3606 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 3607 return err 3608 } 3609 } 3610 3611 if v.ChangeSetName != nil { 3612 objectKey := object.Key("ChangeSetName") 3613 objectKey.String(*v.ChangeSetName) 3614 } 3615 3616 if len(v.ChangeSetType) > 0 { 3617 objectKey := object.Key("ChangeSetType") 3618 objectKey.String(string(v.ChangeSetType)) 3619 } 3620 3621 if v.ClientToken != nil { 3622 objectKey := object.Key("ClientToken") 3623 objectKey.String(*v.ClientToken) 3624 } 3625 3626 if v.Description != nil { 3627 objectKey := object.Key("Description") 3628 objectKey.String(*v.Description) 3629 } 3630 3631 if v.IncludeNestedStacks != nil { 3632 objectKey := object.Key("IncludeNestedStacks") 3633 objectKey.Boolean(*v.IncludeNestedStacks) 3634 } 3635 3636 if v.NotificationARNs != nil { 3637 objectKey := object.Key("NotificationARNs") 3638 if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil { 3639 return err 3640 } 3641 } 3642 3643 if v.Parameters != nil { 3644 objectKey := object.Key("Parameters") 3645 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 3646 return err 3647 } 3648 } 3649 3650 if v.ResourcesToImport != nil { 3651 objectKey := object.Key("ResourcesToImport") 3652 if err := awsAwsquery_serializeDocumentResourcesToImport(v.ResourcesToImport, objectKey); err != nil { 3653 return err 3654 } 3655 } 3656 3657 if v.ResourceTypes != nil { 3658 objectKey := object.Key("ResourceTypes") 3659 if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil { 3660 return err 3661 } 3662 } 3663 3664 if v.RoleARN != nil { 3665 objectKey := object.Key("RoleARN") 3666 objectKey.String(*v.RoleARN) 3667 } 3668 3669 if v.RollbackConfiguration != nil { 3670 objectKey := object.Key("RollbackConfiguration") 3671 if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil { 3672 return err 3673 } 3674 } 3675 3676 if v.StackName != nil { 3677 objectKey := object.Key("StackName") 3678 objectKey.String(*v.StackName) 3679 } 3680 3681 if v.Tags != nil { 3682 objectKey := object.Key("Tags") 3683 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 3684 return err 3685 } 3686 } 3687 3688 if v.TemplateBody != nil { 3689 objectKey := object.Key("TemplateBody") 3690 objectKey.String(*v.TemplateBody) 3691 } 3692 3693 if v.TemplateURL != nil { 3694 objectKey := object.Key("TemplateURL") 3695 objectKey.String(*v.TemplateURL) 3696 } 3697 3698 if v.UsePreviousTemplate != nil { 3699 objectKey := object.Key("UsePreviousTemplate") 3700 objectKey.Boolean(*v.UsePreviousTemplate) 3701 } 3702 3703 return nil 3704} 3705 3706func awsAwsquery_serializeOpDocumentCreateStackInput(v *CreateStackInput, value query.Value) error { 3707 object := value.Object() 3708 _ = object 3709 3710 if v.Capabilities != nil { 3711 objectKey := object.Key("Capabilities") 3712 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 3713 return err 3714 } 3715 } 3716 3717 if v.ClientRequestToken != nil { 3718 objectKey := object.Key("ClientRequestToken") 3719 objectKey.String(*v.ClientRequestToken) 3720 } 3721 3722 if v.DisableRollback != nil { 3723 objectKey := object.Key("DisableRollback") 3724 objectKey.Boolean(*v.DisableRollback) 3725 } 3726 3727 if v.EnableTerminationProtection != nil { 3728 objectKey := object.Key("EnableTerminationProtection") 3729 objectKey.Boolean(*v.EnableTerminationProtection) 3730 } 3731 3732 if v.NotificationARNs != nil { 3733 objectKey := object.Key("NotificationARNs") 3734 if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil { 3735 return err 3736 } 3737 } 3738 3739 if len(v.OnFailure) > 0 { 3740 objectKey := object.Key("OnFailure") 3741 objectKey.String(string(v.OnFailure)) 3742 } 3743 3744 if v.Parameters != nil { 3745 objectKey := object.Key("Parameters") 3746 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 3747 return err 3748 } 3749 } 3750 3751 if v.ResourceTypes != nil { 3752 objectKey := object.Key("ResourceTypes") 3753 if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil { 3754 return err 3755 } 3756 } 3757 3758 if v.RoleARN != nil { 3759 objectKey := object.Key("RoleARN") 3760 objectKey.String(*v.RoleARN) 3761 } 3762 3763 if v.RollbackConfiguration != nil { 3764 objectKey := object.Key("RollbackConfiguration") 3765 if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil { 3766 return err 3767 } 3768 } 3769 3770 if v.StackName != nil { 3771 objectKey := object.Key("StackName") 3772 objectKey.String(*v.StackName) 3773 } 3774 3775 if v.StackPolicyBody != nil { 3776 objectKey := object.Key("StackPolicyBody") 3777 objectKey.String(*v.StackPolicyBody) 3778 } 3779 3780 if v.StackPolicyURL != nil { 3781 objectKey := object.Key("StackPolicyURL") 3782 objectKey.String(*v.StackPolicyURL) 3783 } 3784 3785 if v.Tags != nil { 3786 objectKey := object.Key("Tags") 3787 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 3788 return err 3789 } 3790 } 3791 3792 if v.TemplateBody != nil { 3793 objectKey := object.Key("TemplateBody") 3794 objectKey.String(*v.TemplateBody) 3795 } 3796 3797 if v.TemplateURL != nil { 3798 objectKey := object.Key("TemplateURL") 3799 objectKey.String(*v.TemplateURL) 3800 } 3801 3802 if v.TimeoutInMinutes != nil { 3803 objectKey := object.Key("TimeoutInMinutes") 3804 objectKey.Integer(*v.TimeoutInMinutes) 3805 } 3806 3807 return nil 3808} 3809 3810func awsAwsquery_serializeOpDocumentCreateStackInstancesInput(v *CreateStackInstancesInput, value query.Value) error { 3811 object := value.Object() 3812 _ = object 3813 3814 if v.Accounts != nil { 3815 objectKey := object.Key("Accounts") 3816 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 3817 return err 3818 } 3819 } 3820 3821 if len(v.CallAs) > 0 { 3822 objectKey := object.Key("CallAs") 3823 objectKey.String(string(v.CallAs)) 3824 } 3825 3826 if v.DeploymentTargets != nil { 3827 objectKey := object.Key("DeploymentTargets") 3828 if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil { 3829 return err 3830 } 3831 } 3832 3833 if v.OperationId != nil { 3834 objectKey := object.Key("OperationId") 3835 objectKey.String(*v.OperationId) 3836 } 3837 3838 if v.OperationPreferences != nil { 3839 objectKey := object.Key("OperationPreferences") 3840 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 3841 return err 3842 } 3843 } 3844 3845 if v.ParameterOverrides != nil { 3846 objectKey := object.Key("ParameterOverrides") 3847 if err := awsAwsquery_serializeDocumentParameters(v.ParameterOverrides, objectKey); err != nil { 3848 return err 3849 } 3850 } 3851 3852 if v.Regions != nil { 3853 objectKey := object.Key("Regions") 3854 if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil { 3855 return err 3856 } 3857 } 3858 3859 if v.StackSetName != nil { 3860 objectKey := object.Key("StackSetName") 3861 objectKey.String(*v.StackSetName) 3862 } 3863 3864 return nil 3865} 3866 3867func awsAwsquery_serializeOpDocumentCreateStackSetInput(v *CreateStackSetInput, value query.Value) error { 3868 object := value.Object() 3869 _ = object 3870 3871 if v.AdministrationRoleARN != nil { 3872 objectKey := object.Key("AdministrationRoleARN") 3873 objectKey.String(*v.AdministrationRoleARN) 3874 } 3875 3876 if v.AutoDeployment != nil { 3877 objectKey := object.Key("AutoDeployment") 3878 if err := awsAwsquery_serializeDocumentAutoDeployment(v.AutoDeployment, objectKey); err != nil { 3879 return err 3880 } 3881 } 3882 3883 if len(v.CallAs) > 0 { 3884 objectKey := object.Key("CallAs") 3885 objectKey.String(string(v.CallAs)) 3886 } 3887 3888 if v.Capabilities != nil { 3889 objectKey := object.Key("Capabilities") 3890 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 3891 return err 3892 } 3893 } 3894 3895 if v.ClientRequestToken != nil { 3896 objectKey := object.Key("ClientRequestToken") 3897 objectKey.String(*v.ClientRequestToken) 3898 } 3899 3900 if v.Description != nil { 3901 objectKey := object.Key("Description") 3902 objectKey.String(*v.Description) 3903 } 3904 3905 if v.ExecutionRoleName != nil { 3906 objectKey := object.Key("ExecutionRoleName") 3907 objectKey.String(*v.ExecutionRoleName) 3908 } 3909 3910 if v.Parameters != nil { 3911 objectKey := object.Key("Parameters") 3912 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 3913 return err 3914 } 3915 } 3916 3917 if len(v.PermissionModel) > 0 { 3918 objectKey := object.Key("PermissionModel") 3919 objectKey.String(string(v.PermissionModel)) 3920 } 3921 3922 if v.StackSetName != nil { 3923 objectKey := object.Key("StackSetName") 3924 objectKey.String(*v.StackSetName) 3925 } 3926 3927 if v.Tags != nil { 3928 objectKey := object.Key("Tags") 3929 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 3930 return err 3931 } 3932 } 3933 3934 if v.TemplateBody != nil { 3935 objectKey := object.Key("TemplateBody") 3936 objectKey.String(*v.TemplateBody) 3937 } 3938 3939 if v.TemplateURL != nil { 3940 objectKey := object.Key("TemplateURL") 3941 objectKey.String(*v.TemplateURL) 3942 } 3943 3944 return nil 3945} 3946 3947func awsAwsquery_serializeOpDocumentDeleteChangeSetInput(v *DeleteChangeSetInput, value query.Value) error { 3948 object := value.Object() 3949 _ = object 3950 3951 if v.ChangeSetName != nil { 3952 objectKey := object.Key("ChangeSetName") 3953 objectKey.String(*v.ChangeSetName) 3954 } 3955 3956 if v.StackName != nil { 3957 objectKey := object.Key("StackName") 3958 objectKey.String(*v.StackName) 3959 } 3960 3961 return nil 3962} 3963 3964func awsAwsquery_serializeOpDocumentDeleteStackInput(v *DeleteStackInput, value query.Value) error { 3965 object := value.Object() 3966 _ = object 3967 3968 if v.ClientRequestToken != nil { 3969 objectKey := object.Key("ClientRequestToken") 3970 objectKey.String(*v.ClientRequestToken) 3971 } 3972 3973 if v.RetainResources != nil { 3974 objectKey := object.Key("RetainResources") 3975 if err := awsAwsquery_serializeDocumentRetainResources(v.RetainResources, objectKey); err != nil { 3976 return err 3977 } 3978 } 3979 3980 if v.RoleARN != nil { 3981 objectKey := object.Key("RoleARN") 3982 objectKey.String(*v.RoleARN) 3983 } 3984 3985 if v.StackName != nil { 3986 objectKey := object.Key("StackName") 3987 objectKey.String(*v.StackName) 3988 } 3989 3990 return nil 3991} 3992 3993func awsAwsquery_serializeOpDocumentDeleteStackInstancesInput(v *DeleteStackInstancesInput, value query.Value) error { 3994 object := value.Object() 3995 _ = object 3996 3997 if v.Accounts != nil { 3998 objectKey := object.Key("Accounts") 3999 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 4000 return err 4001 } 4002 } 4003 4004 if len(v.CallAs) > 0 { 4005 objectKey := object.Key("CallAs") 4006 objectKey.String(string(v.CallAs)) 4007 } 4008 4009 if v.DeploymentTargets != nil { 4010 objectKey := object.Key("DeploymentTargets") 4011 if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil { 4012 return err 4013 } 4014 } 4015 4016 if v.OperationId != nil { 4017 objectKey := object.Key("OperationId") 4018 objectKey.String(*v.OperationId) 4019 } 4020 4021 if v.OperationPreferences != nil { 4022 objectKey := object.Key("OperationPreferences") 4023 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 4024 return err 4025 } 4026 } 4027 4028 if v.Regions != nil { 4029 objectKey := object.Key("Regions") 4030 if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil { 4031 return err 4032 } 4033 } 4034 4035 { 4036 objectKey := object.Key("RetainStacks") 4037 objectKey.Boolean(v.RetainStacks) 4038 } 4039 4040 if v.StackSetName != nil { 4041 objectKey := object.Key("StackSetName") 4042 objectKey.String(*v.StackSetName) 4043 } 4044 4045 return nil 4046} 4047 4048func awsAwsquery_serializeOpDocumentDeleteStackSetInput(v *DeleteStackSetInput, value query.Value) error { 4049 object := value.Object() 4050 _ = object 4051 4052 if len(v.CallAs) > 0 { 4053 objectKey := object.Key("CallAs") 4054 objectKey.String(string(v.CallAs)) 4055 } 4056 4057 if v.StackSetName != nil { 4058 objectKey := object.Key("StackSetName") 4059 objectKey.String(*v.StackSetName) 4060 } 4061 4062 return nil 4063} 4064 4065func awsAwsquery_serializeOpDocumentDeregisterTypeInput(v *DeregisterTypeInput, value query.Value) error { 4066 object := value.Object() 4067 _ = object 4068 4069 if v.Arn != nil { 4070 objectKey := object.Key("Arn") 4071 objectKey.String(*v.Arn) 4072 } 4073 4074 if len(v.Type) > 0 { 4075 objectKey := object.Key("Type") 4076 objectKey.String(string(v.Type)) 4077 } 4078 4079 if v.TypeName != nil { 4080 objectKey := object.Key("TypeName") 4081 objectKey.String(*v.TypeName) 4082 } 4083 4084 if v.VersionId != nil { 4085 objectKey := object.Key("VersionId") 4086 objectKey.String(*v.VersionId) 4087 } 4088 4089 return nil 4090} 4091 4092func awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(v *DescribeAccountLimitsInput, value query.Value) error { 4093 object := value.Object() 4094 _ = object 4095 4096 if v.NextToken != nil { 4097 objectKey := object.Key("NextToken") 4098 objectKey.String(*v.NextToken) 4099 } 4100 4101 return nil 4102} 4103 4104func awsAwsquery_serializeOpDocumentDescribeChangeSetInput(v *DescribeChangeSetInput, value query.Value) error { 4105 object := value.Object() 4106 _ = object 4107 4108 if v.ChangeSetName != nil { 4109 objectKey := object.Key("ChangeSetName") 4110 objectKey.String(*v.ChangeSetName) 4111 } 4112 4113 if v.NextToken != nil { 4114 objectKey := object.Key("NextToken") 4115 objectKey.String(*v.NextToken) 4116 } 4117 4118 if v.StackName != nil { 4119 objectKey := object.Key("StackName") 4120 objectKey.String(*v.StackName) 4121 } 4122 4123 return nil 4124} 4125 4126func awsAwsquery_serializeOpDocumentDescribeStackDriftDetectionStatusInput(v *DescribeStackDriftDetectionStatusInput, value query.Value) error { 4127 object := value.Object() 4128 _ = object 4129 4130 if v.StackDriftDetectionId != nil { 4131 objectKey := object.Key("StackDriftDetectionId") 4132 objectKey.String(*v.StackDriftDetectionId) 4133 } 4134 4135 return nil 4136} 4137 4138func awsAwsquery_serializeOpDocumentDescribeStackEventsInput(v *DescribeStackEventsInput, value query.Value) error { 4139 object := value.Object() 4140 _ = object 4141 4142 if v.NextToken != nil { 4143 objectKey := object.Key("NextToken") 4144 objectKey.String(*v.NextToken) 4145 } 4146 4147 if v.StackName != nil { 4148 objectKey := object.Key("StackName") 4149 objectKey.String(*v.StackName) 4150 } 4151 4152 return nil 4153} 4154 4155func awsAwsquery_serializeOpDocumentDescribeStackInstanceInput(v *DescribeStackInstanceInput, value query.Value) error { 4156 object := value.Object() 4157 _ = object 4158 4159 if len(v.CallAs) > 0 { 4160 objectKey := object.Key("CallAs") 4161 objectKey.String(string(v.CallAs)) 4162 } 4163 4164 if v.StackInstanceAccount != nil { 4165 objectKey := object.Key("StackInstanceAccount") 4166 objectKey.String(*v.StackInstanceAccount) 4167 } 4168 4169 if v.StackInstanceRegion != nil { 4170 objectKey := object.Key("StackInstanceRegion") 4171 objectKey.String(*v.StackInstanceRegion) 4172 } 4173 4174 if v.StackSetName != nil { 4175 objectKey := object.Key("StackSetName") 4176 objectKey.String(*v.StackSetName) 4177 } 4178 4179 return nil 4180} 4181 4182func awsAwsquery_serializeOpDocumentDescribeStackResourceDriftsInput(v *DescribeStackResourceDriftsInput, value query.Value) error { 4183 object := value.Object() 4184 _ = object 4185 4186 if v.MaxResults != nil { 4187 objectKey := object.Key("MaxResults") 4188 objectKey.Integer(*v.MaxResults) 4189 } 4190 4191 if v.NextToken != nil { 4192 objectKey := object.Key("NextToken") 4193 objectKey.String(*v.NextToken) 4194 } 4195 4196 if v.StackName != nil { 4197 objectKey := object.Key("StackName") 4198 objectKey.String(*v.StackName) 4199 } 4200 4201 if v.StackResourceDriftStatusFilters != nil { 4202 objectKey := object.Key("StackResourceDriftStatusFilters") 4203 if err := awsAwsquery_serializeDocumentStackResourceDriftStatusFilters(v.StackResourceDriftStatusFilters, objectKey); err != nil { 4204 return err 4205 } 4206 } 4207 4208 return nil 4209} 4210 4211func awsAwsquery_serializeOpDocumentDescribeStackResourceInput(v *DescribeStackResourceInput, value query.Value) error { 4212 object := value.Object() 4213 _ = object 4214 4215 if v.LogicalResourceId != nil { 4216 objectKey := object.Key("LogicalResourceId") 4217 objectKey.String(*v.LogicalResourceId) 4218 } 4219 4220 if v.StackName != nil { 4221 objectKey := object.Key("StackName") 4222 objectKey.String(*v.StackName) 4223 } 4224 4225 return nil 4226} 4227 4228func awsAwsquery_serializeOpDocumentDescribeStackResourcesInput(v *DescribeStackResourcesInput, value query.Value) error { 4229 object := value.Object() 4230 _ = object 4231 4232 if v.LogicalResourceId != nil { 4233 objectKey := object.Key("LogicalResourceId") 4234 objectKey.String(*v.LogicalResourceId) 4235 } 4236 4237 if v.PhysicalResourceId != nil { 4238 objectKey := object.Key("PhysicalResourceId") 4239 objectKey.String(*v.PhysicalResourceId) 4240 } 4241 4242 if v.StackName != nil { 4243 objectKey := object.Key("StackName") 4244 objectKey.String(*v.StackName) 4245 } 4246 4247 return nil 4248} 4249 4250func awsAwsquery_serializeOpDocumentDescribeStackSetInput(v *DescribeStackSetInput, value query.Value) error { 4251 object := value.Object() 4252 _ = object 4253 4254 if len(v.CallAs) > 0 { 4255 objectKey := object.Key("CallAs") 4256 objectKey.String(string(v.CallAs)) 4257 } 4258 4259 if v.StackSetName != nil { 4260 objectKey := object.Key("StackSetName") 4261 objectKey.String(*v.StackSetName) 4262 } 4263 4264 return nil 4265} 4266 4267func awsAwsquery_serializeOpDocumentDescribeStackSetOperationInput(v *DescribeStackSetOperationInput, value query.Value) error { 4268 object := value.Object() 4269 _ = object 4270 4271 if len(v.CallAs) > 0 { 4272 objectKey := object.Key("CallAs") 4273 objectKey.String(string(v.CallAs)) 4274 } 4275 4276 if v.OperationId != nil { 4277 objectKey := object.Key("OperationId") 4278 objectKey.String(*v.OperationId) 4279 } 4280 4281 if v.StackSetName != nil { 4282 objectKey := object.Key("StackSetName") 4283 objectKey.String(*v.StackSetName) 4284 } 4285 4286 return nil 4287} 4288 4289func awsAwsquery_serializeOpDocumentDescribeStacksInput(v *DescribeStacksInput, value query.Value) error { 4290 object := value.Object() 4291 _ = object 4292 4293 if v.NextToken != nil { 4294 objectKey := object.Key("NextToken") 4295 objectKey.String(*v.NextToken) 4296 } 4297 4298 if v.StackName != nil { 4299 objectKey := object.Key("StackName") 4300 objectKey.String(*v.StackName) 4301 } 4302 4303 return nil 4304} 4305 4306func awsAwsquery_serializeOpDocumentDescribeTypeInput(v *DescribeTypeInput, value query.Value) error { 4307 object := value.Object() 4308 _ = object 4309 4310 if v.Arn != nil { 4311 objectKey := object.Key("Arn") 4312 objectKey.String(*v.Arn) 4313 } 4314 4315 if len(v.Type) > 0 { 4316 objectKey := object.Key("Type") 4317 objectKey.String(string(v.Type)) 4318 } 4319 4320 if v.TypeName != nil { 4321 objectKey := object.Key("TypeName") 4322 objectKey.String(*v.TypeName) 4323 } 4324 4325 if v.VersionId != nil { 4326 objectKey := object.Key("VersionId") 4327 objectKey.String(*v.VersionId) 4328 } 4329 4330 return nil 4331} 4332 4333func awsAwsquery_serializeOpDocumentDescribeTypeRegistrationInput(v *DescribeTypeRegistrationInput, value query.Value) error { 4334 object := value.Object() 4335 _ = object 4336 4337 if v.RegistrationToken != nil { 4338 objectKey := object.Key("RegistrationToken") 4339 objectKey.String(*v.RegistrationToken) 4340 } 4341 4342 return nil 4343} 4344 4345func awsAwsquery_serializeOpDocumentDetectStackDriftInput(v *DetectStackDriftInput, value query.Value) error { 4346 object := value.Object() 4347 _ = object 4348 4349 if v.LogicalResourceIds != nil { 4350 objectKey := object.Key("LogicalResourceIds") 4351 if err := awsAwsquery_serializeDocumentLogicalResourceIds(v.LogicalResourceIds, objectKey); err != nil { 4352 return err 4353 } 4354 } 4355 4356 if v.StackName != nil { 4357 objectKey := object.Key("StackName") 4358 objectKey.String(*v.StackName) 4359 } 4360 4361 return nil 4362} 4363 4364func awsAwsquery_serializeOpDocumentDetectStackResourceDriftInput(v *DetectStackResourceDriftInput, value query.Value) error { 4365 object := value.Object() 4366 _ = object 4367 4368 if v.LogicalResourceId != nil { 4369 objectKey := object.Key("LogicalResourceId") 4370 objectKey.String(*v.LogicalResourceId) 4371 } 4372 4373 if v.StackName != nil { 4374 objectKey := object.Key("StackName") 4375 objectKey.String(*v.StackName) 4376 } 4377 4378 return nil 4379} 4380 4381func awsAwsquery_serializeOpDocumentDetectStackSetDriftInput(v *DetectStackSetDriftInput, value query.Value) error { 4382 object := value.Object() 4383 _ = object 4384 4385 if len(v.CallAs) > 0 { 4386 objectKey := object.Key("CallAs") 4387 objectKey.String(string(v.CallAs)) 4388 } 4389 4390 if v.OperationId != nil { 4391 objectKey := object.Key("OperationId") 4392 objectKey.String(*v.OperationId) 4393 } 4394 4395 if v.OperationPreferences != nil { 4396 objectKey := object.Key("OperationPreferences") 4397 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 4398 return err 4399 } 4400 } 4401 4402 if v.StackSetName != nil { 4403 objectKey := object.Key("StackSetName") 4404 objectKey.String(*v.StackSetName) 4405 } 4406 4407 return nil 4408} 4409 4410func awsAwsquery_serializeOpDocumentEstimateTemplateCostInput(v *EstimateTemplateCostInput, value query.Value) error { 4411 object := value.Object() 4412 _ = object 4413 4414 if v.Parameters != nil { 4415 objectKey := object.Key("Parameters") 4416 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 4417 return err 4418 } 4419 } 4420 4421 if v.TemplateBody != nil { 4422 objectKey := object.Key("TemplateBody") 4423 objectKey.String(*v.TemplateBody) 4424 } 4425 4426 if v.TemplateURL != nil { 4427 objectKey := object.Key("TemplateURL") 4428 objectKey.String(*v.TemplateURL) 4429 } 4430 4431 return nil 4432} 4433 4434func awsAwsquery_serializeOpDocumentExecuteChangeSetInput(v *ExecuteChangeSetInput, value query.Value) error { 4435 object := value.Object() 4436 _ = object 4437 4438 if v.ChangeSetName != nil { 4439 objectKey := object.Key("ChangeSetName") 4440 objectKey.String(*v.ChangeSetName) 4441 } 4442 4443 if v.ClientRequestToken != nil { 4444 objectKey := object.Key("ClientRequestToken") 4445 objectKey.String(*v.ClientRequestToken) 4446 } 4447 4448 if v.StackName != nil { 4449 objectKey := object.Key("StackName") 4450 objectKey.String(*v.StackName) 4451 } 4452 4453 return nil 4454} 4455 4456func awsAwsquery_serializeOpDocumentGetStackPolicyInput(v *GetStackPolicyInput, value query.Value) error { 4457 object := value.Object() 4458 _ = object 4459 4460 if v.StackName != nil { 4461 objectKey := object.Key("StackName") 4462 objectKey.String(*v.StackName) 4463 } 4464 4465 return nil 4466} 4467 4468func awsAwsquery_serializeOpDocumentGetTemplateInput(v *GetTemplateInput, value query.Value) error { 4469 object := value.Object() 4470 _ = object 4471 4472 if v.ChangeSetName != nil { 4473 objectKey := object.Key("ChangeSetName") 4474 objectKey.String(*v.ChangeSetName) 4475 } 4476 4477 if v.StackName != nil { 4478 objectKey := object.Key("StackName") 4479 objectKey.String(*v.StackName) 4480 } 4481 4482 if len(v.TemplateStage) > 0 { 4483 objectKey := object.Key("TemplateStage") 4484 objectKey.String(string(v.TemplateStage)) 4485 } 4486 4487 return nil 4488} 4489 4490func awsAwsquery_serializeOpDocumentGetTemplateSummaryInput(v *GetTemplateSummaryInput, value query.Value) error { 4491 object := value.Object() 4492 _ = object 4493 4494 if v.StackName != nil { 4495 objectKey := object.Key("StackName") 4496 objectKey.String(*v.StackName) 4497 } 4498 4499 if v.StackSetName != nil { 4500 objectKey := object.Key("StackSetName") 4501 objectKey.String(*v.StackSetName) 4502 } 4503 4504 if v.TemplateBody != nil { 4505 objectKey := object.Key("TemplateBody") 4506 objectKey.String(*v.TemplateBody) 4507 } 4508 4509 if v.TemplateURL != nil { 4510 objectKey := object.Key("TemplateURL") 4511 objectKey.String(*v.TemplateURL) 4512 } 4513 4514 return nil 4515} 4516 4517func awsAwsquery_serializeOpDocumentListChangeSetsInput(v *ListChangeSetsInput, value query.Value) error { 4518 object := value.Object() 4519 _ = object 4520 4521 if v.NextToken != nil { 4522 objectKey := object.Key("NextToken") 4523 objectKey.String(*v.NextToken) 4524 } 4525 4526 if v.StackName != nil { 4527 objectKey := object.Key("StackName") 4528 objectKey.String(*v.StackName) 4529 } 4530 4531 return nil 4532} 4533 4534func awsAwsquery_serializeOpDocumentListExportsInput(v *ListExportsInput, value query.Value) error { 4535 object := value.Object() 4536 _ = object 4537 4538 if v.NextToken != nil { 4539 objectKey := object.Key("NextToken") 4540 objectKey.String(*v.NextToken) 4541 } 4542 4543 return nil 4544} 4545 4546func awsAwsquery_serializeOpDocumentListImportsInput(v *ListImportsInput, value query.Value) error { 4547 object := value.Object() 4548 _ = object 4549 4550 if v.ExportName != nil { 4551 objectKey := object.Key("ExportName") 4552 objectKey.String(*v.ExportName) 4553 } 4554 4555 if v.NextToken != nil { 4556 objectKey := object.Key("NextToken") 4557 objectKey.String(*v.NextToken) 4558 } 4559 4560 return nil 4561} 4562 4563func awsAwsquery_serializeOpDocumentListStackInstancesInput(v *ListStackInstancesInput, value query.Value) error { 4564 object := value.Object() 4565 _ = object 4566 4567 if len(v.CallAs) > 0 { 4568 objectKey := object.Key("CallAs") 4569 objectKey.String(string(v.CallAs)) 4570 } 4571 4572 if v.Filters != nil { 4573 objectKey := object.Key("Filters") 4574 if err := awsAwsquery_serializeDocumentStackInstanceFilters(v.Filters, objectKey); err != nil { 4575 return err 4576 } 4577 } 4578 4579 if v.MaxResults != nil { 4580 objectKey := object.Key("MaxResults") 4581 objectKey.Integer(*v.MaxResults) 4582 } 4583 4584 if v.NextToken != nil { 4585 objectKey := object.Key("NextToken") 4586 objectKey.String(*v.NextToken) 4587 } 4588 4589 if v.StackInstanceAccount != nil { 4590 objectKey := object.Key("StackInstanceAccount") 4591 objectKey.String(*v.StackInstanceAccount) 4592 } 4593 4594 if v.StackInstanceRegion != nil { 4595 objectKey := object.Key("StackInstanceRegion") 4596 objectKey.String(*v.StackInstanceRegion) 4597 } 4598 4599 if v.StackSetName != nil { 4600 objectKey := object.Key("StackSetName") 4601 objectKey.String(*v.StackSetName) 4602 } 4603 4604 return nil 4605} 4606 4607func awsAwsquery_serializeOpDocumentListStackResourcesInput(v *ListStackResourcesInput, value query.Value) error { 4608 object := value.Object() 4609 _ = object 4610 4611 if v.NextToken != nil { 4612 objectKey := object.Key("NextToken") 4613 objectKey.String(*v.NextToken) 4614 } 4615 4616 if v.StackName != nil { 4617 objectKey := object.Key("StackName") 4618 objectKey.String(*v.StackName) 4619 } 4620 4621 return nil 4622} 4623 4624func awsAwsquery_serializeOpDocumentListStackSetOperationResultsInput(v *ListStackSetOperationResultsInput, value query.Value) error { 4625 object := value.Object() 4626 _ = object 4627 4628 if len(v.CallAs) > 0 { 4629 objectKey := object.Key("CallAs") 4630 objectKey.String(string(v.CallAs)) 4631 } 4632 4633 if v.MaxResults != nil { 4634 objectKey := object.Key("MaxResults") 4635 objectKey.Integer(*v.MaxResults) 4636 } 4637 4638 if v.NextToken != nil { 4639 objectKey := object.Key("NextToken") 4640 objectKey.String(*v.NextToken) 4641 } 4642 4643 if v.OperationId != nil { 4644 objectKey := object.Key("OperationId") 4645 objectKey.String(*v.OperationId) 4646 } 4647 4648 if v.StackSetName != nil { 4649 objectKey := object.Key("StackSetName") 4650 objectKey.String(*v.StackSetName) 4651 } 4652 4653 return nil 4654} 4655 4656func awsAwsquery_serializeOpDocumentListStackSetOperationsInput(v *ListStackSetOperationsInput, value query.Value) error { 4657 object := value.Object() 4658 _ = object 4659 4660 if len(v.CallAs) > 0 { 4661 objectKey := object.Key("CallAs") 4662 objectKey.String(string(v.CallAs)) 4663 } 4664 4665 if v.MaxResults != nil { 4666 objectKey := object.Key("MaxResults") 4667 objectKey.Integer(*v.MaxResults) 4668 } 4669 4670 if v.NextToken != nil { 4671 objectKey := object.Key("NextToken") 4672 objectKey.String(*v.NextToken) 4673 } 4674 4675 if v.StackSetName != nil { 4676 objectKey := object.Key("StackSetName") 4677 objectKey.String(*v.StackSetName) 4678 } 4679 4680 return nil 4681} 4682 4683func awsAwsquery_serializeOpDocumentListStackSetsInput(v *ListStackSetsInput, value query.Value) error { 4684 object := value.Object() 4685 _ = object 4686 4687 if len(v.CallAs) > 0 { 4688 objectKey := object.Key("CallAs") 4689 objectKey.String(string(v.CallAs)) 4690 } 4691 4692 if v.MaxResults != nil { 4693 objectKey := object.Key("MaxResults") 4694 objectKey.Integer(*v.MaxResults) 4695 } 4696 4697 if v.NextToken != nil { 4698 objectKey := object.Key("NextToken") 4699 objectKey.String(*v.NextToken) 4700 } 4701 4702 if len(v.Status) > 0 { 4703 objectKey := object.Key("Status") 4704 objectKey.String(string(v.Status)) 4705 } 4706 4707 return nil 4708} 4709 4710func awsAwsquery_serializeOpDocumentListStacksInput(v *ListStacksInput, value query.Value) error { 4711 object := value.Object() 4712 _ = object 4713 4714 if v.NextToken != nil { 4715 objectKey := object.Key("NextToken") 4716 objectKey.String(*v.NextToken) 4717 } 4718 4719 if v.StackStatusFilter != nil { 4720 objectKey := object.Key("StackStatusFilter") 4721 if err := awsAwsquery_serializeDocumentStackStatusFilter(v.StackStatusFilter, objectKey); err != nil { 4722 return err 4723 } 4724 } 4725 4726 return nil 4727} 4728 4729func awsAwsquery_serializeOpDocumentListTypeRegistrationsInput(v *ListTypeRegistrationsInput, value query.Value) error { 4730 object := value.Object() 4731 _ = object 4732 4733 if v.MaxResults != nil { 4734 objectKey := object.Key("MaxResults") 4735 objectKey.Integer(*v.MaxResults) 4736 } 4737 4738 if v.NextToken != nil { 4739 objectKey := object.Key("NextToken") 4740 objectKey.String(*v.NextToken) 4741 } 4742 4743 if len(v.RegistrationStatusFilter) > 0 { 4744 objectKey := object.Key("RegistrationStatusFilter") 4745 objectKey.String(string(v.RegistrationStatusFilter)) 4746 } 4747 4748 if len(v.Type) > 0 { 4749 objectKey := object.Key("Type") 4750 objectKey.String(string(v.Type)) 4751 } 4752 4753 if v.TypeArn != nil { 4754 objectKey := object.Key("TypeArn") 4755 objectKey.String(*v.TypeArn) 4756 } 4757 4758 if v.TypeName != nil { 4759 objectKey := object.Key("TypeName") 4760 objectKey.String(*v.TypeName) 4761 } 4762 4763 return nil 4764} 4765 4766func awsAwsquery_serializeOpDocumentListTypesInput(v *ListTypesInput, value query.Value) error { 4767 object := value.Object() 4768 _ = object 4769 4770 if len(v.DeprecatedStatus) > 0 { 4771 objectKey := object.Key("DeprecatedStatus") 4772 objectKey.String(string(v.DeprecatedStatus)) 4773 } 4774 4775 if v.MaxResults != nil { 4776 objectKey := object.Key("MaxResults") 4777 objectKey.Integer(*v.MaxResults) 4778 } 4779 4780 if v.NextToken != nil { 4781 objectKey := object.Key("NextToken") 4782 objectKey.String(*v.NextToken) 4783 } 4784 4785 if len(v.ProvisioningType) > 0 { 4786 objectKey := object.Key("ProvisioningType") 4787 objectKey.String(string(v.ProvisioningType)) 4788 } 4789 4790 if len(v.Type) > 0 { 4791 objectKey := object.Key("Type") 4792 objectKey.String(string(v.Type)) 4793 } 4794 4795 if len(v.Visibility) > 0 { 4796 objectKey := object.Key("Visibility") 4797 objectKey.String(string(v.Visibility)) 4798 } 4799 4800 return nil 4801} 4802 4803func awsAwsquery_serializeOpDocumentListTypeVersionsInput(v *ListTypeVersionsInput, value query.Value) error { 4804 object := value.Object() 4805 _ = object 4806 4807 if v.Arn != nil { 4808 objectKey := object.Key("Arn") 4809 objectKey.String(*v.Arn) 4810 } 4811 4812 if len(v.DeprecatedStatus) > 0 { 4813 objectKey := object.Key("DeprecatedStatus") 4814 objectKey.String(string(v.DeprecatedStatus)) 4815 } 4816 4817 if v.MaxResults != nil { 4818 objectKey := object.Key("MaxResults") 4819 objectKey.Integer(*v.MaxResults) 4820 } 4821 4822 if v.NextToken != nil { 4823 objectKey := object.Key("NextToken") 4824 objectKey.String(*v.NextToken) 4825 } 4826 4827 if len(v.Type) > 0 { 4828 objectKey := object.Key("Type") 4829 objectKey.String(string(v.Type)) 4830 } 4831 4832 if v.TypeName != nil { 4833 objectKey := object.Key("TypeName") 4834 objectKey.String(*v.TypeName) 4835 } 4836 4837 return nil 4838} 4839 4840func awsAwsquery_serializeOpDocumentRecordHandlerProgressInput(v *RecordHandlerProgressInput, value query.Value) error { 4841 object := value.Object() 4842 _ = object 4843 4844 if v.BearerToken != nil { 4845 objectKey := object.Key("BearerToken") 4846 objectKey.String(*v.BearerToken) 4847 } 4848 4849 if v.ClientRequestToken != nil { 4850 objectKey := object.Key("ClientRequestToken") 4851 objectKey.String(*v.ClientRequestToken) 4852 } 4853 4854 if len(v.CurrentOperationStatus) > 0 { 4855 objectKey := object.Key("CurrentOperationStatus") 4856 objectKey.String(string(v.CurrentOperationStatus)) 4857 } 4858 4859 if len(v.ErrorCode) > 0 { 4860 objectKey := object.Key("ErrorCode") 4861 objectKey.String(string(v.ErrorCode)) 4862 } 4863 4864 if len(v.OperationStatus) > 0 { 4865 objectKey := object.Key("OperationStatus") 4866 objectKey.String(string(v.OperationStatus)) 4867 } 4868 4869 if v.ResourceModel != nil { 4870 objectKey := object.Key("ResourceModel") 4871 objectKey.String(*v.ResourceModel) 4872 } 4873 4874 if v.StatusMessage != nil { 4875 objectKey := object.Key("StatusMessage") 4876 objectKey.String(*v.StatusMessage) 4877 } 4878 4879 return nil 4880} 4881 4882func awsAwsquery_serializeOpDocumentRegisterTypeInput(v *RegisterTypeInput, value query.Value) error { 4883 object := value.Object() 4884 _ = object 4885 4886 if v.ClientRequestToken != nil { 4887 objectKey := object.Key("ClientRequestToken") 4888 objectKey.String(*v.ClientRequestToken) 4889 } 4890 4891 if v.ExecutionRoleArn != nil { 4892 objectKey := object.Key("ExecutionRoleArn") 4893 objectKey.String(*v.ExecutionRoleArn) 4894 } 4895 4896 if v.LoggingConfig != nil { 4897 objectKey := object.Key("LoggingConfig") 4898 if err := awsAwsquery_serializeDocumentLoggingConfig(v.LoggingConfig, objectKey); err != nil { 4899 return err 4900 } 4901 } 4902 4903 if v.SchemaHandlerPackage != nil { 4904 objectKey := object.Key("SchemaHandlerPackage") 4905 objectKey.String(*v.SchemaHandlerPackage) 4906 } 4907 4908 if len(v.Type) > 0 { 4909 objectKey := object.Key("Type") 4910 objectKey.String(string(v.Type)) 4911 } 4912 4913 if v.TypeName != nil { 4914 objectKey := object.Key("TypeName") 4915 objectKey.String(*v.TypeName) 4916 } 4917 4918 return nil 4919} 4920 4921func awsAwsquery_serializeOpDocumentSetStackPolicyInput(v *SetStackPolicyInput, value query.Value) error { 4922 object := value.Object() 4923 _ = object 4924 4925 if v.StackName != nil { 4926 objectKey := object.Key("StackName") 4927 objectKey.String(*v.StackName) 4928 } 4929 4930 if v.StackPolicyBody != nil { 4931 objectKey := object.Key("StackPolicyBody") 4932 objectKey.String(*v.StackPolicyBody) 4933 } 4934 4935 if v.StackPolicyURL != nil { 4936 objectKey := object.Key("StackPolicyURL") 4937 objectKey.String(*v.StackPolicyURL) 4938 } 4939 4940 return nil 4941} 4942 4943func awsAwsquery_serializeOpDocumentSetTypeDefaultVersionInput(v *SetTypeDefaultVersionInput, value query.Value) error { 4944 object := value.Object() 4945 _ = object 4946 4947 if v.Arn != nil { 4948 objectKey := object.Key("Arn") 4949 objectKey.String(*v.Arn) 4950 } 4951 4952 if len(v.Type) > 0 { 4953 objectKey := object.Key("Type") 4954 objectKey.String(string(v.Type)) 4955 } 4956 4957 if v.TypeName != nil { 4958 objectKey := object.Key("TypeName") 4959 objectKey.String(*v.TypeName) 4960 } 4961 4962 if v.VersionId != nil { 4963 objectKey := object.Key("VersionId") 4964 objectKey.String(*v.VersionId) 4965 } 4966 4967 return nil 4968} 4969 4970func awsAwsquery_serializeOpDocumentSignalResourceInput(v *SignalResourceInput, value query.Value) error { 4971 object := value.Object() 4972 _ = object 4973 4974 if v.LogicalResourceId != nil { 4975 objectKey := object.Key("LogicalResourceId") 4976 objectKey.String(*v.LogicalResourceId) 4977 } 4978 4979 if v.StackName != nil { 4980 objectKey := object.Key("StackName") 4981 objectKey.String(*v.StackName) 4982 } 4983 4984 if len(v.Status) > 0 { 4985 objectKey := object.Key("Status") 4986 objectKey.String(string(v.Status)) 4987 } 4988 4989 if v.UniqueId != nil { 4990 objectKey := object.Key("UniqueId") 4991 objectKey.String(*v.UniqueId) 4992 } 4993 4994 return nil 4995} 4996 4997func awsAwsquery_serializeOpDocumentStopStackSetOperationInput(v *StopStackSetOperationInput, value query.Value) error { 4998 object := value.Object() 4999 _ = object 5000 5001 if len(v.CallAs) > 0 { 5002 objectKey := object.Key("CallAs") 5003 objectKey.String(string(v.CallAs)) 5004 } 5005 5006 if v.OperationId != nil { 5007 objectKey := object.Key("OperationId") 5008 objectKey.String(*v.OperationId) 5009 } 5010 5011 if v.StackSetName != nil { 5012 objectKey := object.Key("StackSetName") 5013 objectKey.String(*v.StackSetName) 5014 } 5015 5016 return nil 5017} 5018 5019func awsAwsquery_serializeOpDocumentUpdateStackInput(v *UpdateStackInput, value query.Value) error { 5020 object := value.Object() 5021 _ = object 5022 5023 if v.Capabilities != nil { 5024 objectKey := object.Key("Capabilities") 5025 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 5026 return err 5027 } 5028 } 5029 5030 if v.ClientRequestToken != nil { 5031 objectKey := object.Key("ClientRequestToken") 5032 objectKey.String(*v.ClientRequestToken) 5033 } 5034 5035 if v.NotificationARNs != nil { 5036 objectKey := object.Key("NotificationARNs") 5037 if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil { 5038 return err 5039 } 5040 } 5041 5042 if v.Parameters != nil { 5043 objectKey := object.Key("Parameters") 5044 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 5045 return err 5046 } 5047 } 5048 5049 if v.ResourceTypes != nil { 5050 objectKey := object.Key("ResourceTypes") 5051 if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil { 5052 return err 5053 } 5054 } 5055 5056 if v.RoleARN != nil { 5057 objectKey := object.Key("RoleARN") 5058 objectKey.String(*v.RoleARN) 5059 } 5060 5061 if v.RollbackConfiguration != nil { 5062 objectKey := object.Key("RollbackConfiguration") 5063 if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil { 5064 return err 5065 } 5066 } 5067 5068 if v.StackName != nil { 5069 objectKey := object.Key("StackName") 5070 objectKey.String(*v.StackName) 5071 } 5072 5073 if v.StackPolicyBody != nil { 5074 objectKey := object.Key("StackPolicyBody") 5075 objectKey.String(*v.StackPolicyBody) 5076 } 5077 5078 if v.StackPolicyDuringUpdateBody != nil { 5079 objectKey := object.Key("StackPolicyDuringUpdateBody") 5080 objectKey.String(*v.StackPolicyDuringUpdateBody) 5081 } 5082 5083 if v.StackPolicyDuringUpdateURL != nil { 5084 objectKey := object.Key("StackPolicyDuringUpdateURL") 5085 objectKey.String(*v.StackPolicyDuringUpdateURL) 5086 } 5087 5088 if v.StackPolicyURL != nil { 5089 objectKey := object.Key("StackPolicyURL") 5090 objectKey.String(*v.StackPolicyURL) 5091 } 5092 5093 if v.Tags != nil { 5094 objectKey := object.Key("Tags") 5095 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 5096 return err 5097 } 5098 } 5099 5100 if v.TemplateBody != nil { 5101 objectKey := object.Key("TemplateBody") 5102 objectKey.String(*v.TemplateBody) 5103 } 5104 5105 if v.TemplateURL != nil { 5106 objectKey := object.Key("TemplateURL") 5107 objectKey.String(*v.TemplateURL) 5108 } 5109 5110 if v.UsePreviousTemplate != nil { 5111 objectKey := object.Key("UsePreviousTemplate") 5112 objectKey.Boolean(*v.UsePreviousTemplate) 5113 } 5114 5115 return nil 5116} 5117 5118func awsAwsquery_serializeOpDocumentUpdateStackInstancesInput(v *UpdateStackInstancesInput, value query.Value) error { 5119 object := value.Object() 5120 _ = object 5121 5122 if v.Accounts != nil { 5123 objectKey := object.Key("Accounts") 5124 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 5125 return err 5126 } 5127 } 5128 5129 if len(v.CallAs) > 0 { 5130 objectKey := object.Key("CallAs") 5131 objectKey.String(string(v.CallAs)) 5132 } 5133 5134 if v.DeploymentTargets != nil { 5135 objectKey := object.Key("DeploymentTargets") 5136 if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil { 5137 return err 5138 } 5139 } 5140 5141 if v.OperationId != nil { 5142 objectKey := object.Key("OperationId") 5143 objectKey.String(*v.OperationId) 5144 } 5145 5146 if v.OperationPreferences != nil { 5147 objectKey := object.Key("OperationPreferences") 5148 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 5149 return err 5150 } 5151 } 5152 5153 if v.ParameterOverrides != nil { 5154 objectKey := object.Key("ParameterOverrides") 5155 if err := awsAwsquery_serializeDocumentParameters(v.ParameterOverrides, objectKey); err != nil { 5156 return err 5157 } 5158 } 5159 5160 if v.Regions != nil { 5161 objectKey := object.Key("Regions") 5162 if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil { 5163 return err 5164 } 5165 } 5166 5167 if v.StackSetName != nil { 5168 objectKey := object.Key("StackSetName") 5169 objectKey.String(*v.StackSetName) 5170 } 5171 5172 return nil 5173} 5174 5175func awsAwsquery_serializeOpDocumentUpdateStackSetInput(v *UpdateStackSetInput, value query.Value) error { 5176 object := value.Object() 5177 _ = object 5178 5179 if v.Accounts != nil { 5180 objectKey := object.Key("Accounts") 5181 if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil { 5182 return err 5183 } 5184 } 5185 5186 if v.AdministrationRoleARN != nil { 5187 objectKey := object.Key("AdministrationRoleARN") 5188 objectKey.String(*v.AdministrationRoleARN) 5189 } 5190 5191 if v.AutoDeployment != nil { 5192 objectKey := object.Key("AutoDeployment") 5193 if err := awsAwsquery_serializeDocumentAutoDeployment(v.AutoDeployment, objectKey); err != nil { 5194 return err 5195 } 5196 } 5197 5198 if len(v.CallAs) > 0 { 5199 objectKey := object.Key("CallAs") 5200 objectKey.String(string(v.CallAs)) 5201 } 5202 5203 if v.Capabilities != nil { 5204 objectKey := object.Key("Capabilities") 5205 if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil { 5206 return err 5207 } 5208 } 5209 5210 if v.DeploymentTargets != nil { 5211 objectKey := object.Key("DeploymentTargets") 5212 if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil { 5213 return err 5214 } 5215 } 5216 5217 if v.Description != nil { 5218 objectKey := object.Key("Description") 5219 objectKey.String(*v.Description) 5220 } 5221 5222 if v.ExecutionRoleName != nil { 5223 objectKey := object.Key("ExecutionRoleName") 5224 objectKey.String(*v.ExecutionRoleName) 5225 } 5226 5227 if v.OperationId != nil { 5228 objectKey := object.Key("OperationId") 5229 objectKey.String(*v.OperationId) 5230 } 5231 5232 if v.OperationPreferences != nil { 5233 objectKey := object.Key("OperationPreferences") 5234 if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil { 5235 return err 5236 } 5237 } 5238 5239 if v.Parameters != nil { 5240 objectKey := object.Key("Parameters") 5241 if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil { 5242 return err 5243 } 5244 } 5245 5246 if len(v.PermissionModel) > 0 { 5247 objectKey := object.Key("PermissionModel") 5248 objectKey.String(string(v.PermissionModel)) 5249 } 5250 5251 if v.Regions != nil { 5252 objectKey := object.Key("Regions") 5253 if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil { 5254 return err 5255 } 5256 } 5257 5258 if v.StackSetName != nil { 5259 objectKey := object.Key("StackSetName") 5260 objectKey.String(*v.StackSetName) 5261 } 5262 5263 if v.Tags != nil { 5264 objectKey := object.Key("Tags") 5265 if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil { 5266 return err 5267 } 5268 } 5269 5270 if v.TemplateBody != nil { 5271 objectKey := object.Key("TemplateBody") 5272 objectKey.String(*v.TemplateBody) 5273 } 5274 5275 if v.TemplateURL != nil { 5276 objectKey := object.Key("TemplateURL") 5277 objectKey.String(*v.TemplateURL) 5278 } 5279 5280 if v.UsePreviousTemplate != nil { 5281 objectKey := object.Key("UsePreviousTemplate") 5282 objectKey.Boolean(*v.UsePreviousTemplate) 5283 } 5284 5285 return nil 5286} 5287 5288func awsAwsquery_serializeOpDocumentUpdateTerminationProtectionInput(v *UpdateTerminationProtectionInput, value query.Value) error { 5289 object := value.Object() 5290 _ = object 5291 5292 if v.EnableTerminationProtection != nil { 5293 objectKey := object.Key("EnableTerminationProtection") 5294 objectKey.Boolean(*v.EnableTerminationProtection) 5295 } 5296 5297 if v.StackName != nil { 5298 objectKey := object.Key("StackName") 5299 objectKey.String(*v.StackName) 5300 } 5301 5302 return nil 5303} 5304 5305func awsAwsquery_serializeOpDocumentValidateTemplateInput(v *ValidateTemplateInput, value query.Value) error { 5306 object := value.Object() 5307 _ = object 5308 5309 if v.TemplateBody != nil { 5310 objectKey := object.Key("TemplateBody") 5311 objectKey.String(*v.TemplateBody) 5312 } 5313 5314 if v.TemplateURL != nil { 5315 objectKey := object.Key("TemplateURL") 5316 objectKey.String(*v.TemplateURL) 5317 } 5318 5319 return nil 5320} 5321