1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package appconfig 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/appconfig/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsRestjson1_serializeOpCreateApplication struct { 18} 19 20func (*awsRestjson1_serializeOpCreateApplication) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpCreateApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 25 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 26) { 27 request, ok := in.Request.(*smithyhttp.Request) 28 if !ok { 29 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 30 } 31 32 input, ok := in.Parameters.(*CreateApplicationInput) 33 _ = input 34 if !ok { 35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 36 } 37 38 opPath, opQuery := httpbinding.SplitURI("/applications") 39 request.URL.Path = opPath 40 if len(request.URL.RawQuery) > 0 { 41 request.URL.RawQuery = "&" + opQuery 42 } else { 43 request.URL.RawQuery = opQuery 44 } 45 46 request.Method = "POST" 47 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 48 if err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 restEncoder.SetHeader("Content-Type").String("application/json") 53 54 jsonEncoder := smithyjson.NewEncoder() 55 if err := awsRestjson1_serializeOpDocumentCreateApplicationInput(input, jsonEncoder.Value); err != nil { 56 return out, metadata, &smithy.SerializationError{Err: err} 57 } 58 59 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 63 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 64 return out, metadata, &smithy.SerializationError{Err: err} 65 } 66 in.Request = request 67 68 return next.HandleSerialize(ctx, in) 69} 70func awsRestjson1_serializeOpHttpBindingsCreateApplicationInput(v *CreateApplicationInput, encoder *httpbinding.Encoder) error { 71 if v == nil { 72 return fmt.Errorf("unsupported serialization of nil %T", v) 73 } 74 75 return nil 76} 77 78func awsRestjson1_serializeOpDocumentCreateApplicationInput(v *CreateApplicationInput, value smithyjson.Value) error { 79 object := value.Object() 80 defer object.Close() 81 82 if v.Description != nil { 83 ok := object.Key("Description") 84 ok.String(*v.Description) 85 } 86 87 if v.Name != nil { 88 ok := object.Key("Name") 89 ok.String(*v.Name) 90 } 91 92 if v.Tags != nil { 93 ok := object.Key("Tags") 94 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 95 return err 96 } 97 } 98 99 return nil 100} 101 102type awsRestjson1_serializeOpCreateConfigurationProfile struct { 103} 104 105func (*awsRestjson1_serializeOpCreateConfigurationProfile) ID() string { 106 return "OperationSerializer" 107} 108 109func (m *awsRestjson1_serializeOpCreateConfigurationProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 110 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 111) { 112 request, ok := in.Request.(*smithyhttp.Request) 113 if !ok { 114 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 115 } 116 117 input, ok := in.Parameters.(*CreateConfigurationProfileInput) 118 _ = input 119 if !ok { 120 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 121 } 122 123 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles") 124 request.URL.Path = opPath 125 if len(request.URL.RawQuery) > 0 { 126 request.URL.RawQuery = "&" + opQuery 127 } else { 128 request.URL.RawQuery = opQuery 129 } 130 131 request.Method = "POST" 132 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 133 if err != nil { 134 return out, metadata, &smithy.SerializationError{Err: err} 135 } 136 137 if err := awsRestjson1_serializeOpHttpBindingsCreateConfigurationProfileInput(input, restEncoder); err != nil { 138 return out, metadata, &smithy.SerializationError{Err: err} 139 } 140 141 restEncoder.SetHeader("Content-Type").String("application/json") 142 143 jsonEncoder := smithyjson.NewEncoder() 144 if err := awsRestjson1_serializeOpDocumentCreateConfigurationProfileInput(input, jsonEncoder.Value); err != nil { 145 return out, metadata, &smithy.SerializationError{Err: err} 146 } 147 148 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 149 return out, metadata, &smithy.SerializationError{Err: err} 150 } 151 152 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 153 return out, metadata, &smithy.SerializationError{Err: err} 154 } 155 in.Request = request 156 157 return next.HandleSerialize(ctx, in) 158} 159func awsRestjson1_serializeOpHttpBindingsCreateConfigurationProfileInput(v *CreateConfigurationProfileInput, encoder *httpbinding.Encoder) error { 160 if v == nil { 161 return fmt.Errorf("unsupported serialization of nil %T", v) 162 } 163 164 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 165 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 166 } 167 if v.ApplicationId != nil { 168 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 169 return err 170 } 171 } 172 173 return nil 174} 175 176func awsRestjson1_serializeOpDocumentCreateConfigurationProfileInput(v *CreateConfigurationProfileInput, value smithyjson.Value) error { 177 object := value.Object() 178 defer object.Close() 179 180 if v.Description != nil { 181 ok := object.Key("Description") 182 ok.String(*v.Description) 183 } 184 185 if v.LocationUri != nil { 186 ok := object.Key("LocationUri") 187 ok.String(*v.LocationUri) 188 } 189 190 if v.Name != nil { 191 ok := object.Key("Name") 192 ok.String(*v.Name) 193 } 194 195 if v.RetrievalRoleArn != nil { 196 ok := object.Key("RetrievalRoleArn") 197 ok.String(*v.RetrievalRoleArn) 198 } 199 200 if v.Tags != nil { 201 ok := object.Key("Tags") 202 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 203 return err 204 } 205 } 206 207 if v.Validators != nil { 208 ok := object.Key("Validators") 209 if err := awsRestjson1_serializeDocumentValidatorList(v.Validators, ok); err != nil { 210 return err 211 } 212 } 213 214 return nil 215} 216 217type awsRestjson1_serializeOpCreateDeploymentStrategy struct { 218} 219 220func (*awsRestjson1_serializeOpCreateDeploymentStrategy) ID() string { 221 return "OperationSerializer" 222} 223 224func (m *awsRestjson1_serializeOpCreateDeploymentStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 225 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 226) { 227 request, ok := in.Request.(*smithyhttp.Request) 228 if !ok { 229 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 230 } 231 232 input, ok := in.Parameters.(*CreateDeploymentStrategyInput) 233 _ = input 234 if !ok { 235 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 236 } 237 238 opPath, opQuery := httpbinding.SplitURI("/deploymentstrategies") 239 request.URL.Path = opPath 240 if len(request.URL.RawQuery) > 0 { 241 request.URL.RawQuery = "&" + opQuery 242 } else { 243 request.URL.RawQuery = opQuery 244 } 245 246 request.Method = "POST" 247 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 248 if err != nil { 249 return out, metadata, &smithy.SerializationError{Err: err} 250 } 251 252 restEncoder.SetHeader("Content-Type").String("application/json") 253 254 jsonEncoder := smithyjson.NewEncoder() 255 if err := awsRestjson1_serializeOpDocumentCreateDeploymentStrategyInput(input, jsonEncoder.Value); err != nil { 256 return out, metadata, &smithy.SerializationError{Err: err} 257 } 258 259 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 260 return out, metadata, &smithy.SerializationError{Err: err} 261 } 262 263 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 264 return out, metadata, &smithy.SerializationError{Err: err} 265 } 266 in.Request = request 267 268 return next.HandleSerialize(ctx, in) 269} 270func awsRestjson1_serializeOpHttpBindingsCreateDeploymentStrategyInput(v *CreateDeploymentStrategyInput, encoder *httpbinding.Encoder) error { 271 if v == nil { 272 return fmt.Errorf("unsupported serialization of nil %T", v) 273 } 274 275 return nil 276} 277 278func awsRestjson1_serializeOpDocumentCreateDeploymentStrategyInput(v *CreateDeploymentStrategyInput, value smithyjson.Value) error { 279 object := value.Object() 280 defer object.Close() 281 282 if v.DeploymentDurationInMinutes != 0 { 283 ok := object.Key("DeploymentDurationInMinutes") 284 ok.Integer(v.DeploymentDurationInMinutes) 285 } 286 287 if v.Description != nil { 288 ok := object.Key("Description") 289 ok.String(*v.Description) 290 } 291 292 if v.FinalBakeTimeInMinutes != 0 { 293 ok := object.Key("FinalBakeTimeInMinutes") 294 ok.Integer(v.FinalBakeTimeInMinutes) 295 } 296 297 if v.GrowthFactor != 0 { 298 ok := object.Key("GrowthFactor") 299 ok.Float(v.GrowthFactor) 300 } 301 302 if len(v.GrowthType) > 0 { 303 ok := object.Key("GrowthType") 304 ok.String(string(v.GrowthType)) 305 } 306 307 if v.Name != nil { 308 ok := object.Key("Name") 309 ok.String(*v.Name) 310 } 311 312 if len(v.ReplicateTo) > 0 { 313 ok := object.Key("ReplicateTo") 314 ok.String(string(v.ReplicateTo)) 315 } 316 317 if v.Tags != nil { 318 ok := object.Key("Tags") 319 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 320 return err 321 } 322 } 323 324 return nil 325} 326 327type awsRestjson1_serializeOpCreateEnvironment struct { 328} 329 330func (*awsRestjson1_serializeOpCreateEnvironment) ID() string { 331 return "OperationSerializer" 332} 333 334func (m *awsRestjson1_serializeOpCreateEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 335 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 336) { 337 request, ok := in.Request.(*smithyhttp.Request) 338 if !ok { 339 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 340 } 341 342 input, ok := in.Parameters.(*CreateEnvironmentInput) 343 _ = input 344 if !ok { 345 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 346 } 347 348 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments") 349 request.URL.Path = opPath 350 if len(request.URL.RawQuery) > 0 { 351 request.URL.RawQuery = "&" + opQuery 352 } else { 353 request.URL.RawQuery = opQuery 354 } 355 356 request.Method = "POST" 357 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 358 if err != nil { 359 return out, metadata, &smithy.SerializationError{Err: err} 360 } 361 362 if err := awsRestjson1_serializeOpHttpBindingsCreateEnvironmentInput(input, restEncoder); err != nil { 363 return out, metadata, &smithy.SerializationError{Err: err} 364 } 365 366 restEncoder.SetHeader("Content-Type").String("application/json") 367 368 jsonEncoder := smithyjson.NewEncoder() 369 if err := awsRestjson1_serializeOpDocumentCreateEnvironmentInput(input, jsonEncoder.Value); err != nil { 370 return out, metadata, &smithy.SerializationError{Err: err} 371 } 372 373 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 374 return out, metadata, &smithy.SerializationError{Err: err} 375 } 376 377 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 378 return out, metadata, &smithy.SerializationError{Err: err} 379 } 380 in.Request = request 381 382 return next.HandleSerialize(ctx, in) 383} 384func awsRestjson1_serializeOpHttpBindingsCreateEnvironmentInput(v *CreateEnvironmentInput, encoder *httpbinding.Encoder) error { 385 if v == nil { 386 return fmt.Errorf("unsupported serialization of nil %T", v) 387 } 388 389 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 390 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 391 } 392 if v.ApplicationId != nil { 393 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 394 return err 395 } 396 } 397 398 return nil 399} 400 401func awsRestjson1_serializeOpDocumentCreateEnvironmentInput(v *CreateEnvironmentInput, value smithyjson.Value) error { 402 object := value.Object() 403 defer object.Close() 404 405 if v.Description != nil { 406 ok := object.Key("Description") 407 ok.String(*v.Description) 408 } 409 410 if v.Monitors != nil { 411 ok := object.Key("Monitors") 412 if err := awsRestjson1_serializeDocumentMonitorList(v.Monitors, ok); err != nil { 413 return err 414 } 415 } 416 417 if v.Name != nil { 418 ok := object.Key("Name") 419 ok.String(*v.Name) 420 } 421 422 if v.Tags != nil { 423 ok := object.Key("Tags") 424 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 425 return err 426 } 427 } 428 429 return nil 430} 431 432type awsRestjson1_serializeOpCreateHostedConfigurationVersion struct { 433} 434 435func (*awsRestjson1_serializeOpCreateHostedConfigurationVersion) ID() string { 436 return "OperationSerializer" 437} 438 439func (m *awsRestjson1_serializeOpCreateHostedConfigurationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 440 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 441) { 442 request, ok := in.Request.(*smithyhttp.Request) 443 if !ok { 444 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 445 } 446 447 input, ok := in.Parameters.(*CreateHostedConfigurationVersionInput) 448 _ = input 449 if !ok { 450 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 451 } 452 453 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/hostedconfigurationversions") 454 request.URL.Path = opPath 455 if len(request.URL.RawQuery) > 0 { 456 request.URL.RawQuery = "&" + opQuery 457 } else { 458 request.URL.RawQuery = opQuery 459 } 460 461 request.Method = "POST" 462 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 463 if err != nil { 464 return out, metadata, &smithy.SerializationError{Err: err} 465 } 466 467 if err := awsRestjson1_serializeOpHttpBindingsCreateHostedConfigurationVersionInput(input, restEncoder); err != nil { 468 return out, metadata, &smithy.SerializationError{Err: err} 469 } 470 471 if input.Content != nil { 472 if !restEncoder.HasHeader("Content-Type") { 473 restEncoder.SetHeader("Content-Type").String("application/octet-stream") 474 } 475 476 payload := bytes.NewReader(input.Content) 477 if request, err = request.SetStream(payload); err != nil { 478 return out, metadata, &smithy.SerializationError{Err: err} 479 } 480 } 481 482 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 483 return out, metadata, &smithy.SerializationError{Err: err} 484 } 485 in.Request = request 486 487 return next.HandleSerialize(ctx, in) 488} 489func awsRestjson1_serializeOpHttpBindingsCreateHostedConfigurationVersionInput(v *CreateHostedConfigurationVersionInput, encoder *httpbinding.Encoder) error { 490 if v == nil { 491 return fmt.Errorf("unsupported serialization of nil %T", v) 492 } 493 494 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 495 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 496 } 497 if v.ApplicationId != nil { 498 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 499 return err 500 } 501 } 502 503 if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 { 504 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")} 505 } 506 if v.ConfigurationProfileId != nil { 507 if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil { 508 return err 509 } 510 } 511 512 if v.ContentType != nil && len(*v.ContentType) > 0 { 513 locationName := "Content-Type" 514 encoder.SetHeader(locationName).String(*v.ContentType) 515 } 516 517 if v.Description != nil && len(*v.Description) > 0 { 518 locationName := "Description" 519 encoder.SetHeader(locationName).String(*v.Description) 520 } 521 522 if v.LatestVersionNumber != 0 { 523 locationName := "Latest-Version-Number" 524 encoder.SetHeader(locationName).Integer(v.LatestVersionNumber) 525 } 526 527 return nil 528} 529 530type awsRestjson1_serializeOpDeleteApplication struct { 531} 532 533func (*awsRestjson1_serializeOpDeleteApplication) ID() string { 534 return "OperationSerializer" 535} 536 537func (m *awsRestjson1_serializeOpDeleteApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 538 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 539) { 540 request, ok := in.Request.(*smithyhttp.Request) 541 if !ok { 542 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 543 } 544 545 input, ok := in.Parameters.(*DeleteApplicationInput) 546 _ = input 547 if !ok { 548 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 549 } 550 551 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}") 552 request.URL.Path = opPath 553 if len(request.URL.RawQuery) > 0 { 554 request.URL.RawQuery = "&" + opQuery 555 } else { 556 request.URL.RawQuery = opQuery 557 } 558 559 request.Method = "DELETE" 560 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 561 if err != nil { 562 return out, metadata, &smithy.SerializationError{Err: err} 563 } 564 565 if err := awsRestjson1_serializeOpHttpBindingsDeleteApplicationInput(input, restEncoder); err != nil { 566 return out, metadata, &smithy.SerializationError{Err: err} 567 } 568 569 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 570 return out, metadata, &smithy.SerializationError{Err: err} 571 } 572 in.Request = request 573 574 return next.HandleSerialize(ctx, in) 575} 576func awsRestjson1_serializeOpHttpBindingsDeleteApplicationInput(v *DeleteApplicationInput, encoder *httpbinding.Encoder) error { 577 if v == nil { 578 return fmt.Errorf("unsupported serialization of nil %T", v) 579 } 580 581 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 582 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 583 } 584 if v.ApplicationId != nil { 585 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 586 return err 587 } 588 } 589 590 return nil 591} 592 593type awsRestjson1_serializeOpDeleteConfigurationProfile struct { 594} 595 596func (*awsRestjson1_serializeOpDeleteConfigurationProfile) ID() string { 597 return "OperationSerializer" 598} 599 600func (m *awsRestjson1_serializeOpDeleteConfigurationProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 601 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 602) { 603 request, ok := in.Request.(*smithyhttp.Request) 604 if !ok { 605 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 606 } 607 608 input, ok := in.Parameters.(*DeleteConfigurationProfileInput) 609 _ = input 610 if !ok { 611 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 612 } 613 614 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}") 615 request.URL.Path = opPath 616 if len(request.URL.RawQuery) > 0 { 617 request.URL.RawQuery = "&" + opQuery 618 } else { 619 request.URL.RawQuery = opQuery 620 } 621 622 request.Method = "DELETE" 623 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 624 if err != nil { 625 return out, metadata, &smithy.SerializationError{Err: err} 626 } 627 628 if err := awsRestjson1_serializeOpHttpBindingsDeleteConfigurationProfileInput(input, restEncoder); err != nil { 629 return out, metadata, &smithy.SerializationError{Err: err} 630 } 631 632 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 633 return out, metadata, &smithy.SerializationError{Err: err} 634 } 635 in.Request = request 636 637 return next.HandleSerialize(ctx, in) 638} 639func awsRestjson1_serializeOpHttpBindingsDeleteConfigurationProfileInput(v *DeleteConfigurationProfileInput, encoder *httpbinding.Encoder) error { 640 if v == nil { 641 return fmt.Errorf("unsupported serialization of nil %T", v) 642 } 643 644 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 645 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 646 } 647 if v.ApplicationId != nil { 648 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 649 return err 650 } 651 } 652 653 if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 { 654 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")} 655 } 656 if v.ConfigurationProfileId != nil { 657 if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil { 658 return err 659 } 660 } 661 662 return nil 663} 664 665type awsRestjson1_serializeOpDeleteDeploymentStrategy struct { 666} 667 668func (*awsRestjson1_serializeOpDeleteDeploymentStrategy) ID() string { 669 return "OperationSerializer" 670} 671 672func (m *awsRestjson1_serializeOpDeleteDeploymentStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 673 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 674) { 675 request, ok := in.Request.(*smithyhttp.Request) 676 if !ok { 677 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 678 } 679 680 input, ok := in.Parameters.(*DeleteDeploymentStrategyInput) 681 _ = input 682 if !ok { 683 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 684 } 685 686 opPath, opQuery := httpbinding.SplitURI("/deployementstrategies/{DeploymentStrategyId}") 687 request.URL.Path = opPath 688 if len(request.URL.RawQuery) > 0 { 689 request.URL.RawQuery = "&" + opQuery 690 } else { 691 request.URL.RawQuery = opQuery 692 } 693 694 request.Method = "DELETE" 695 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 696 if err != nil { 697 return out, metadata, &smithy.SerializationError{Err: err} 698 } 699 700 if err := awsRestjson1_serializeOpHttpBindingsDeleteDeploymentStrategyInput(input, restEncoder); err != nil { 701 return out, metadata, &smithy.SerializationError{Err: err} 702 } 703 704 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 705 return out, metadata, &smithy.SerializationError{Err: err} 706 } 707 in.Request = request 708 709 return next.HandleSerialize(ctx, in) 710} 711func awsRestjson1_serializeOpHttpBindingsDeleteDeploymentStrategyInput(v *DeleteDeploymentStrategyInput, encoder *httpbinding.Encoder) error { 712 if v == nil { 713 return fmt.Errorf("unsupported serialization of nil %T", v) 714 } 715 716 if v.DeploymentStrategyId == nil || len(*v.DeploymentStrategyId) == 0 { 717 return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentStrategyId must not be empty")} 718 } 719 if v.DeploymentStrategyId != nil { 720 if err := encoder.SetURI("DeploymentStrategyId").String(*v.DeploymentStrategyId); err != nil { 721 return err 722 } 723 } 724 725 return nil 726} 727 728type awsRestjson1_serializeOpDeleteEnvironment struct { 729} 730 731func (*awsRestjson1_serializeOpDeleteEnvironment) ID() string { 732 return "OperationSerializer" 733} 734 735func (m *awsRestjson1_serializeOpDeleteEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 736 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 737) { 738 request, ok := in.Request.(*smithyhttp.Request) 739 if !ok { 740 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 741 } 742 743 input, ok := in.Parameters.(*DeleteEnvironmentInput) 744 _ = input 745 if !ok { 746 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 747 } 748 749 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}") 750 request.URL.Path = opPath 751 if len(request.URL.RawQuery) > 0 { 752 request.URL.RawQuery = "&" + opQuery 753 } else { 754 request.URL.RawQuery = opQuery 755 } 756 757 request.Method = "DELETE" 758 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 759 if err != nil { 760 return out, metadata, &smithy.SerializationError{Err: err} 761 } 762 763 if err := awsRestjson1_serializeOpHttpBindingsDeleteEnvironmentInput(input, restEncoder); err != nil { 764 return out, metadata, &smithy.SerializationError{Err: err} 765 } 766 767 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 768 return out, metadata, &smithy.SerializationError{Err: err} 769 } 770 in.Request = request 771 772 return next.HandleSerialize(ctx, in) 773} 774func awsRestjson1_serializeOpHttpBindingsDeleteEnvironmentInput(v *DeleteEnvironmentInput, encoder *httpbinding.Encoder) error { 775 if v == nil { 776 return fmt.Errorf("unsupported serialization of nil %T", v) 777 } 778 779 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 780 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 781 } 782 if v.ApplicationId != nil { 783 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 784 return err 785 } 786 } 787 788 if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 { 789 return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")} 790 } 791 if v.EnvironmentId != nil { 792 if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil { 793 return err 794 } 795 } 796 797 return nil 798} 799 800type awsRestjson1_serializeOpDeleteHostedConfigurationVersion struct { 801} 802 803func (*awsRestjson1_serializeOpDeleteHostedConfigurationVersion) ID() string { 804 return "OperationSerializer" 805} 806 807func (m *awsRestjson1_serializeOpDeleteHostedConfigurationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 808 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 809) { 810 request, ok := in.Request.(*smithyhttp.Request) 811 if !ok { 812 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 813 } 814 815 input, ok := in.Parameters.(*DeleteHostedConfigurationVersionInput) 816 _ = input 817 if !ok { 818 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 819 } 820 821 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/hostedconfigurationversions/{VersionNumber}") 822 request.URL.Path = opPath 823 if len(request.URL.RawQuery) > 0 { 824 request.URL.RawQuery = "&" + opQuery 825 } else { 826 request.URL.RawQuery = opQuery 827 } 828 829 request.Method = "DELETE" 830 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 831 if err != nil { 832 return out, metadata, &smithy.SerializationError{Err: err} 833 } 834 835 if err := awsRestjson1_serializeOpHttpBindingsDeleteHostedConfigurationVersionInput(input, restEncoder); err != nil { 836 return out, metadata, &smithy.SerializationError{Err: err} 837 } 838 839 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 840 return out, metadata, &smithy.SerializationError{Err: err} 841 } 842 in.Request = request 843 844 return next.HandleSerialize(ctx, in) 845} 846func awsRestjson1_serializeOpHttpBindingsDeleteHostedConfigurationVersionInput(v *DeleteHostedConfigurationVersionInput, encoder *httpbinding.Encoder) error { 847 if v == nil { 848 return fmt.Errorf("unsupported serialization of nil %T", v) 849 } 850 851 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 852 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 853 } 854 if v.ApplicationId != nil { 855 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 856 return err 857 } 858 } 859 860 if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 { 861 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")} 862 } 863 if v.ConfigurationProfileId != nil { 864 if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil { 865 return err 866 } 867 } 868 869 if v.VersionNumber == 0 { 870 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionNumber must not be empty")} 871 } 872 if v.VersionNumber != 0 { 873 if err := encoder.SetURI("VersionNumber").Integer(v.VersionNumber); err != nil { 874 return err 875 } 876 } 877 878 return nil 879} 880 881type awsRestjson1_serializeOpGetApplication struct { 882} 883 884func (*awsRestjson1_serializeOpGetApplication) ID() string { 885 return "OperationSerializer" 886} 887 888func (m *awsRestjson1_serializeOpGetApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 889 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 890) { 891 request, ok := in.Request.(*smithyhttp.Request) 892 if !ok { 893 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 894 } 895 896 input, ok := in.Parameters.(*GetApplicationInput) 897 _ = input 898 if !ok { 899 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 900 } 901 902 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}") 903 request.URL.Path = opPath 904 if len(request.URL.RawQuery) > 0 { 905 request.URL.RawQuery = "&" + opQuery 906 } else { 907 request.URL.RawQuery = opQuery 908 } 909 910 request.Method = "GET" 911 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 912 if err != nil { 913 return out, metadata, &smithy.SerializationError{Err: err} 914 } 915 916 if err := awsRestjson1_serializeOpHttpBindingsGetApplicationInput(input, restEncoder); err != nil { 917 return out, metadata, &smithy.SerializationError{Err: err} 918 } 919 920 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 921 return out, metadata, &smithy.SerializationError{Err: err} 922 } 923 in.Request = request 924 925 return next.HandleSerialize(ctx, in) 926} 927func awsRestjson1_serializeOpHttpBindingsGetApplicationInput(v *GetApplicationInput, encoder *httpbinding.Encoder) error { 928 if v == nil { 929 return fmt.Errorf("unsupported serialization of nil %T", v) 930 } 931 932 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 933 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 934 } 935 if v.ApplicationId != nil { 936 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 937 return err 938 } 939 } 940 941 return nil 942} 943 944type awsRestjson1_serializeOpGetConfiguration struct { 945} 946 947func (*awsRestjson1_serializeOpGetConfiguration) ID() string { 948 return "OperationSerializer" 949} 950 951func (m *awsRestjson1_serializeOpGetConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 952 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 953) { 954 request, ok := in.Request.(*smithyhttp.Request) 955 if !ok { 956 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 957 } 958 959 input, ok := in.Parameters.(*GetConfigurationInput) 960 _ = input 961 if !ok { 962 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 963 } 964 965 opPath, opQuery := httpbinding.SplitURI("/applications/{Application}/environments/{Environment}/configurations/{Configuration}") 966 request.URL.Path = opPath 967 if len(request.URL.RawQuery) > 0 { 968 request.URL.RawQuery = "&" + opQuery 969 } else { 970 request.URL.RawQuery = opQuery 971 } 972 973 request.Method = "GET" 974 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 975 if err != nil { 976 return out, metadata, &smithy.SerializationError{Err: err} 977 } 978 979 if err := awsRestjson1_serializeOpHttpBindingsGetConfigurationInput(input, restEncoder); err != nil { 980 return out, metadata, &smithy.SerializationError{Err: err} 981 } 982 983 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 984 return out, metadata, &smithy.SerializationError{Err: err} 985 } 986 in.Request = request 987 988 return next.HandleSerialize(ctx, in) 989} 990func awsRestjson1_serializeOpHttpBindingsGetConfigurationInput(v *GetConfigurationInput, encoder *httpbinding.Encoder) error { 991 if v == nil { 992 return fmt.Errorf("unsupported serialization of nil %T", v) 993 } 994 995 if v.Application == nil || len(*v.Application) == 0 { 996 return &smithy.SerializationError{Err: fmt.Errorf("input member Application must not be empty")} 997 } 998 if v.Application != nil { 999 if err := encoder.SetURI("Application").String(*v.Application); err != nil { 1000 return err 1001 } 1002 } 1003 1004 if v.ClientConfigurationVersion != nil { 1005 encoder.SetQuery("client_configuration_version").String(*v.ClientConfigurationVersion) 1006 } 1007 1008 if v.ClientId != nil { 1009 encoder.SetQuery("client_id").String(*v.ClientId) 1010 } 1011 1012 if v.Configuration == nil || len(*v.Configuration) == 0 { 1013 return &smithy.SerializationError{Err: fmt.Errorf("input member Configuration must not be empty")} 1014 } 1015 if v.Configuration != nil { 1016 if err := encoder.SetURI("Configuration").String(*v.Configuration); err != nil { 1017 return err 1018 } 1019 } 1020 1021 if v.Environment == nil || len(*v.Environment) == 0 { 1022 return &smithy.SerializationError{Err: fmt.Errorf("input member Environment must not be empty")} 1023 } 1024 if v.Environment != nil { 1025 if err := encoder.SetURI("Environment").String(*v.Environment); err != nil { 1026 return err 1027 } 1028 } 1029 1030 return nil 1031} 1032 1033type awsRestjson1_serializeOpGetConfigurationProfile struct { 1034} 1035 1036func (*awsRestjson1_serializeOpGetConfigurationProfile) ID() string { 1037 return "OperationSerializer" 1038} 1039 1040func (m *awsRestjson1_serializeOpGetConfigurationProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1041 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1042) { 1043 request, ok := in.Request.(*smithyhttp.Request) 1044 if !ok { 1045 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1046 } 1047 1048 input, ok := in.Parameters.(*GetConfigurationProfileInput) 1049 _ = input 1050 if !ok { 1051 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1052 } 1053 1054 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}") 1055 request.URL.Path = opPath 1056 if len(request.URL.RawQuery) > 0 { 1057 request.URL.RawQuery = "&" + opQuery 1058 } else { 1059 request.URL.RawQuery = opQuery 1060 } 1061 1062 request.Method = "GET" 1063 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1064 if err != nil { 1065 return out, metadata, &smithy.SerializationError{Err: err} 1066 } 1067 1068 if err := awsRestjson1_serializeOpHttpBindingsGetConfigurationProfileInput(input, restEncoder); err != nil { 1069 return out, metadata, &smithy.SerializationError{Err: err} 1070 } 1071 1072 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1073 return out, metadata, &smithy.SerializationError{Err: err} 1074 } 1075 in.Request = request 1076 1077 return next.HandleSerialize(ctx, in) 1078} 1079func awsRestjson1_serializeOpHttpBindingsGetConfigurationProfileInput(v *GetConfigurationProfileInput, encoder *httpbinding.Encoder) error { 1080 if v == nil { 1081 return fmt.Errorf("unsupported serialization of nil %T", v) 1082 } 1083 1084 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1085 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1086 } 1087 if v.ApplicationId != nil { 1088 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1089 return err 1090 } 1091 } 1092 1093 if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 { 1094 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")} 1095 } 1096 if v.ConfigurationProfileId != nil { 1097 if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil { 1098 return err 1099 } 1100 } 1101 1102 return nil 1103} 1104 1105type awsRestjson1_serializeOpGetDeployment struct { 1106} 1107 1108func (*awsRestjson1_serializeOpGetDeployment) ID() string { 1109 return "OperationSerializer" 1110} 1111 1112func (m *awsRestjson1_serializeOpGetDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1113 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1114) { 1115 request, ok := in.Request.(*smithyhttp.Request) 1116 if !ok { 1117 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1118 } 1119 1120 input, ok := in.Parameters.(*GetDeploymentInput) 1121 _ = input 1122 if !ok { 1123 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1124 } 1125 1126 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}/deployments/{DeploymentNumber}") 1127 request.URL.Path = opPath 1128 if len(request.URL.RawQuery) > 0 { 1129 request.URL.RawQuery = "&" + opQuery 1130 } else { 1131 request.URL.RawQuery = opQuery 1132 } 1133 1134 request.Method = "GET" 1135 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1136 if err != nil { 1137 return out, metadata, &smithy.SerializationError{Err: err} 1138 } 1139 1140 if err := awsRestjson1_serializeOpHttpBindingsGetDeploymentInput(input, restEncoder); err != nil { 1141 return out, metadata, &smithy.SerializationError{Err: err} 1142 } 1143 1144 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1145 return out, metadata, &smithy.SerializationError{Err: err} 1146 } 1147 in.Request = request 1148 1149 return next.HandleSerialize(ctx, in) 1150} 1151func awsRestjson1_serializeOpHttpBindingsGetDeploymentInput(v *GetDeploymentInput, encoder *httpbinding.Encoder) error { 1152 if v == nil { 1153 return fmt.Errorf("unsupported serialization of nil %T", v) 1154 } 1155 1156 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1157 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1158 } 1159 if v.ApplicationId != nil { 1160 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1161 return err 1162 } 1163 } 1164 1165 if v.DeploymentNumber == 0 { 1166 return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentNumber must not be empty")} 1167 } 1168 if v.DeploymentNumber != 0 { 1169 if err := encoder.SetURI("DeploymentNumber").Integer(v.DeploymentNumber); err != nil { 1170 return err 1171 } 1172 } 1173 1174 if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 { 1175 return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")} 1176 } 1177 if v.EnvironmentId != nil { 1178 if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil { 1179 return err 1180 } 1181 } 1182 1183 return nil 1184} 1185 1186type awsRestjson1_serializeOpGetDeploymentStrategy struct { 1187} 1188 1189func (*awsRestjson1_serializeOpGetDeploymentStrategy) ID() string { 1190 return "OperationSerializer" 1191} 1192 1193func (m *awsRestjson1_serializeOpGetDeploymentStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1194 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1195) { 1196 request, ok := in.Request.(*smithyhttp.Request) 1197 if !ok { 1198 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1199 } 1200 1201 input, ok := in.Parameters.(*GetDeploymentStrategyInput) 1202 _ = input 1203 if !ok { 1204 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1205 } 1206 1207 opPath, opQuery := httpbinding.SplitURI("/deploymentstrategies/{DeploymentStrategyId}") 1208 request.URL.Path = opPath 1209 if len(request.URL.RawQuery) > 0 { 1210 request.URL.RawQuery = "&" + opQuery 1211 } else { 1212 request.URL.RawQuery = opQuery 1213 } 1214 1215 request.Method = "GET" 1216 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1217 if err != nil { 1218 return out, metadata, &smithy.SerializationError{Err: err} 1219 } 1220 1221 if err := awsRestjson1_serializeOpHttpBindingsGetDeploymentStrategyInput(input, restEncoder); err != nil { 1222 return out, metadata, &smithy.SerializationError{Err: err} 1223 } 1224 1225 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1226 return out, metadata, &smithy.SerializationError{Err: err} 1227 } 1228 in.Request = request 1229 1230 return next.HandleSerialize(ctx, in) 1231} 1232func awsRestjson1_serializeOpHttpBindingsGetDeploymentStrategyInput(v *GetDeploymentStrategyInput, encoder *httpbinding.Encoder) error { 1233 if v == nil { 1234 return fmt.Errorf("unsupported serialization of nil %T", v) 1235 } 1236 1237 if v.DeploymentStrategyId == nil || len(*v.DeploymentStrategyId) == 0 { 1238 return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentStrategyId must not be empty")} 1239 } 1240 if v.DeploymentStrategyId != nil { 1241 if err := encoder.SetURI("DeploymentStrategyId").String(*v.DeploymentStrategyId); err != nil { 1242 return err 1243 } 1244 } 1245 1246 return nil 1247} 1248 1249type awsRestjson1_serializeOpGetEnvironment struct { 1250} 1251 1252func (*awsRestjson1_serializeOpGetEnvironment) ID() string { 1253 return "OperationSerializer" 1254} 1255 1256func (m *awsRestjson1_serializeOpGetEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1257 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1258) { 1259 request, ok := in.Request.(*smithyhttp.Request) 1260 if !ok { 1261 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1262 } 1263 1264 input, ok := in.Parameters.(*GetEnvironmentInput) 1265 _ = input 1266 if !ok { 1267 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1268 } 1269 1270 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}") 1271 request.URL.Path = opPath 1272 if len(request.URL.RawQuery) > 0 { 1273 request.URL.RawQuery = "&" + opQuery 1274 } else { 1275 request.URL.RawQuery = opQuery 1276 } 1277 1278 request.Method = "GET" 1279 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1280 if err != nil { 1281 return out, metadata, &smithy.SerializationError{Err: err} 1282 } 1283 1284 if err := awsRestjson1_serializeOpHttpBindingsGetEnvironmentInput(input, restEncoder); err != nil { 1285 return out, metadata, &smithy.SerializationError{Err: err} 1286 } 1287 1288 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1289 return out, metadata, &smithy.SerializationError{Err: err} 1290 } 1291 in.Request = request 1292 1293 return next.HandleSerialize(ctx, in) 1294} 1295func awsRestjson1_serializeOpHttpBindingsGetEnvironmentInput(v *GetEnvironmentInput, encoder *httpbinding.Encoder) error { 1296 if v == nil { 1297 return fmt.Errorf("unsupported serialization of nil %T", v) 1298 } 1299 1300 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1301 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1302 } 1303 if v.ApplicationId != nil { 1304 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1305 return err 1306 } 1307 } 1308 1309 if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 { 1310 return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")} 1311 } 1312 if v.EnvironmentId != nil { 1313 if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil { 1314 return err 1315 } 1316 } 1317 1318 return nil 1319} 1320 1321type awsRestjson1_serializeOpGetHostedConfigurationVersion struct { 1322} 1323 1324func (*awsRestjson1_serializeOpGetHostedConfigurationVersion) ID() string { 1325 return "OperationSerializer" 1326} 1327 1328func (m *awsRestjson1_serializeOpGetHostedConfigurationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1329 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1330) { 1331 request, ok := in.Request.(*smithyhttp.Request) 1332 if !ok { 1333 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1334 } 1335 1336 input, ok := in.Parameters.(*GetHostedConfigurationVersionInput) 1337 _ = input 1338 if !ok { 1339 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1340 } 1341 1342 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/hostedconfigurationversions/{VersionNumber}") 1343 request.URL.Path = opPath 1344 if len(request.URL.RawQuery) > 0 { 1345 request.URL.RawQuery = "&" + opQuery 1346 } else { 1347 request.URL.RawQuery = opQuery 1348 } 1349 1350 request.Method = "GET" 1351 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1352 if err != nil { 1353 return out, metadata, &smithy.SerializationError{Err: err} 1354 } 1355 1356 if err := awsRestjson1_serializeOpHttpBindingsGetHostedConfigurationVersionInput(input, restEncoder); err != nil { 1357 return out, metadata, &smithy.SerializationError{Err: err} 1358 } 1359 1360 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1361 return out, metadata, &smithy.SerializationError{Err: err} 1362 } 1363 in.Request = request 1364 1365 return next.HandleSerialize(ctx, in) 1366} 1367func awsRestjson1_serializeOpHttpBindingsGetHostedConfigurationVersionInput(v *GetHostedConfigurationVersionInput, encoder *httpbinding.Encoder) error { 1368 if v == nil { 1369 return fmt.Errorf("unsupported serialization of nil %T", v) 1370 } 1371 1372 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1373 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1374 } 1375 if v.ApplicationId != nil { 1376 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1377 return err 1378 } 1379 } 1380 1381 if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 { 1382 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")} 1383 } 1384 if v.ConfigurationProfileId != nil { 1385 if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil { 1386 return err 1387 } 1388 } 1389 1390 if v.VersionNumber == 0 { 1391 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionNumber must not be empty")} 1392 } 1393 if v.VersionNumber != 0 { 1394 if err := encoder.SetURI("VersionNumber").Integer(v.VersionNumber); err != nil { 1395 return err 1396 } 1397 } 1398 1399 return nil 1400} 1401 1402type awsRestjson1_serializeOpListApplications struct { 1403} 1404 1405func (*awsRestjson1_serializeOpListApplications) ID() string { 1406 return "OperationSerializer" 1407} 1408 1409func (m *awsRestjson1_serializeOpListApplications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1410 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1411) { 1412 request, ok := in.Request.(*smithyhttp.Request) 1413 if !ok { 1414 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1415 } 1416 1417 input, ok := in.Parameters.(*ListApplicationsInput) 1418 _ = input 1419 if !ok { 1420 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1421 } 1422 1423 opPath, opQuery := httpbinding.SplitURI("/applications") 1424 request.URL.Path = opPath 1425 if len(request.URL.RawQuery) > 0 { 1426 request.URL.RawQuery = "&" + opQuery 1427 } else { 1428 request.URL.RawQuery = opQuery 1429 } 1430 1431 request.Method = "GET" 1432 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1433 if err != nil { 1434 return out, metadata, &smithy.SerializationError{Err: err} 1435 } 1436 1437 if err := awsRestjson1_serializeOpHttpBindingsListApplicationsInput(input, restEncoder); err != nil { 1438 return out, metadata, &smithy.SerializationError{Err: err} 1439 } 1440 1441 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1442 return out, metadata, &smithy.SerializationError{Err: err} 1443 } 1444 in.Request = request 1445 1446 return next.HandleSerialize(ctx, in) 1447} 1448func awsRestjson1_serializeOpHttpBindingsListApplicationsInput(v *ListApplicationsInput, encoder *httpbinding.Encoder) error { 1449 if v == nil { 1450 return fmt.Errorf("unsupported serialization of nil %T", v) 1451 } 1452 1453 if v.MaxResults != 0 { 1454 encoder.SetQuery("max_results").Integer(v.MaxResults) 1455 } 1456 1457 if v.NextToken != nil { 1458 encoder.SetQuery("next_token").String(*v.NextToken) 1459 } 1460 1461 return nil 1462} 1463 1464type awsRestjson1_serializeOpListConfigurationProfiles struct { 1465} 1466 1467func (*awsRestjson1_serializeOpListConfigurationProfiles) ID() string { 1468 return "OperationSerializer" 1469} 1470 1471func (m *awsRestjson1_serializeOpListConfigurationProfiles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1472 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1473) { 1474 request, ok := in.Request.(*smithyhttp.Request) 1475 if !ok { 1476 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1477 } 1478 1479 input, ok := in.Parameters.(*ListConfigurationProfilesInput) 1480 _ = input 1481 if !ok { 1482 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1483 } 1484 1485 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles") 1486 request.URL.Path = opPath 1487 if len(request.URL.RawQuery) > 0 { 1488 request.URL.RawQuery = "&" + opQuery 1489 } else { 1490 request.URL.RawQuery = opQuery 1491 } 1492 1493 request.Method = "GET" 1494 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1495 if err != nil { 1496 return out, metadata, &smithy.SerializationError{Err: err} 1497 } 1498 1499 if err := awsRestjson1_serializeOpHttpBindingsListConfigurationProfilesInput(input, restEncoder); err != nil { 1500 return out, metadata, &smithy.SerializationError{Err: err} 1501 } 1502 1503 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1504 return out, metadata, &smithy.SerializationError{Err: err} 1505 } 1506 in.Request = request 1507 1508 return next.HandleSerialize(ctx, in) 1509} 1510func awsRestjson1_serializeOpHttpBindingsListConfigurationProfilesInput(v *ListConfigurationProfilesInput, encoder *httpbinding.Encoder) error { 1511 if v == nil { 1512 return fmt.Errorf("unsupported serialization of nil %T", v) 1513 } 1514 1515 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1516 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1517 } 1518 if v.ApplicationId != nil { 1519 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1520 return err 1521 } 1522 } 1523 1524 if v.MaxResults != 0 { 1525 encoder.SetQuery("max_results").Integer(v.MaxResults) 1526 } 1527 1528 if v.NextToken != nil { 1529 encoder.SetQuery("next_token").String(*v.NextToken) 1530 } 1531 1532 return nil 1533} 1534 1535type awsRestjson1_serializeOpListDeployments struct { 1536} 1537 1538func (*awsRestjson1_serializeOpListDeployments) ID() string { 1539 return "OperationSerializer" 1540} 1541 1542func (m *awsRestjson1_serializeOpListDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1543 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1544) { 1545 request, ok := in.Request.(*smithyhttp.Request) 1546 if !ok { 1547 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1548 } 1549 1550 input, ok := in.Parameters.(*ListDeploymentsInput) 1551 _ = input 1552 if !ok { 1553 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1554 } 1555 1556 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}/deployments") 1557 request.URL.Path = opPath 1558 if len(request.URL.RawQuery) > 0 { 1559 request.URL.RawQuery = "&" + opQuery 1560 } else { 1561 request.URL.RawQuery = opQuery 1562 } 1563 1564 request.Method = "GET" 1565 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1566 if err != nil { 1567 return out, metadata, &smithy.SerializationError{Err: err} 1568 } 1569 1570 if err := awsRestjson1_serializeOpHttpBindingsListDeploymentsInput(input, restEncoder); err != nil { 1571 return out, metadata, &smithy.SerializationError{Err: err} 1572 } 1573 1574 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1575 return out, metadata, &smithy.SerializationError{Err: err} 1576 } 1577 in.Request = request 1578 1579 return next.HandleSerialize(ctx, in) 1580} 1581func awsRestjson1_serializeOpHttpBindingsListDeploymentsInput(v *ListDeploymentsInput, encoder *httpbinding.Encoder) error { 1582 if v == nil { 1583 return fmt.Errorf("unsupported serialization of nil %T", v) 1584 } 1585 1586 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1587 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1588 } 1589 if v.ApplicationId != nil { 1590 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1591 return err 1592 } 1593 } 1594 1595 if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 { 1596 return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")} 1597 } 1598 if v.EnvironmentId != nil { 1599 if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil { 1600 return err 1601 } 1602 } 1603 1604 if v.MaxResults != 0 { 1605 encoder.SetQuery("max_results").Integer(v.MaxResults) 1606 } 1607 1608 if v.NextToken != nil { 1609 encoder.SetQuery("next_token").String(*v.NextToken) 1610 } 1611 1612 return nil 1613} 1614 1615type awsRestjson1_serializeOpListDeploymentStrategies struct { 1616} 1617 1618func (*awsRestjson1_serializeOpListDeploymentStrategies) ID() string { 1619 return "OperationSerializer" 1620} 1621 1622func (m *awsRestjson1_serializeOpListDeploymentStrategies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1623 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1624) { 1625 request, ok := in.Request.(*smithyhttp.Request) 1626 if !ok { 1627 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1628 } 1629 1630 input, ok := in.Parameters.(*ListDeploymentStrategiesInput) 1631 _ = input 1632 if !ok { 1633 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1634 } 1635 1636 opPath, opQuery := httpbinding.SplitURI("/deploymentstrategies") 1637 request.URL.Path = opPath 1638 if len(request.URL.RawQuery) > 0 { 1639 request.URL.RawQuery = "&" + opQuery 1640 } else { 1641 request.URL.RawQuery = opQuery 1642 } 1643 1644 request.Method = "GET" 1645 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1646 if err != nil { 1647 return out, metadata, &smithy.SerializationError{Err: err} 1648 } 1649 1650 if err := awsRestjson1_serializeOpHttpBindingsListDeploymentStrategiesInput(input, restEncoder); err != nil { 1651 return out, metadata, &smithy.SerializationError{Err: err} 1652 } 1653 1654 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1655 return out, metadata, &smithy.SerializationError{Err: err} 1656 } 1657 in.Request = request 1658 1659 return next.HandleSerialize(ctx, in) 1660} 1661func awsRestjson1_serializeOpHttpBindingsListDeploymentStrategiesInput(v *ListDeploymentStrategiesInput, encoder *httpbinding.Encoder) error { 1662 if v == nil { 1663 return fmt.Errorf("unsupported serialization of nil %T", v) 1664 } 1665 1666 if v.MaxResults != 0 { 1667 encoder.SetQuery("max_results").Integer(v.MaxResults) 1668 } 1669 1670 if v.NextToken != nil { 1671 encoder.SetQuery("next_token").String(*v.NextToken) 1672 } 1673 1674 return nil 1675} 1676 1677type awsRestjson1_serializeOpListEnvironments struct { 1678} 1679 1680func (*awsRestjson1_serializeOpListEnvironments) ID() string { 1681 return "OperationSerializer" 1682} 1683 1684func (m *awsRestjson1_serializeOpListEnvironments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1685 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1686) { 1687 request, ok := in.Request.(*smithyhttp.Request) 1688 if !ok { 1689 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1690 } 1691 1692 input, ok := in.Parameters.(*ListEnvironmentsInput) 1693 _ = input 1694 if !ok { 1695 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1696 } 1697 1698 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments") 1699 request.URL.Path = opPath 1700 if len(request.URL.RawQuery) > 0 { 1701 request.URL.RawQuery = "&" + opQuery 1702 } else { 1703 request.URL.RawQuery = opQuery 1704 } 1705 1706 request.Method = "GET" 1707 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1708 if err != nil { 1709 return out, metadata, &smithy.SerializationError{Err: err} 1710 } 1711 1712 if err := awsRestjson1_serializeOpHttpBindingsListEnvironmentsInput(input, restEncoder); err != nil { 1713 return out, metadata, &smithy.SerializationError{Err: err} 1714 } 1715 1716 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1717 return out, metadata, &smithy.SerializationError{Err: err} 1718 } 1719 in.Request = request 1720 1721 return next.HandleSerialize(ctx, in) 1722} 1723func awsRestjson1_serializeOpHttpBindingsListEnvironmentsInput(v *ListEnvironmentsInput, encoder *httpbinding.Encoder) error { 1724 if v == nil { 1725 return fmt.Errorf("unsupported serialization of nil %T", v) 1726 } 1727 1728 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1729 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1730 } 1731 if v.ApplicationId != nil { 1732 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1733 return err 1734 } 1735 } 1736 1737 if v.MaxResults != 0 { 1738 encoder.SetQuery("max_results").Integer(v.MaxResults) 1739 } 1740 1741 if v.NextToken != nil { 1742 encoder.SetQuery("next_token").String(*v.NextToken) 1743 } 1744 1745 return nil 1746} 1747 1748type awsRestjson1_serializeOpListHostedConfigurationVersions struct { 1749} 1750 1751func (*awsRestjson1_serializeOpListHostedConfigurationVersions) ID() string { 1752 return "OperationSerializer" 1753} 1754 1755func (m *awsRestjson1_serializeOpListHostedConfigurationVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1756 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1757) { 1758 request, ok := in.Request.(*smithyhttp.Request) 1759 if !ok { 1760 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1761 } 1762 1763 input, ok := in.Parameters.(*ListHostedConfigurationVersionsInput) 1764 _ = input 1765 if !ok { 1766 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1767 } 1768 1769 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/hostedconfigurationversions") 1770 request.URL.Path = opPath 1771 if len(request.URL.RawQuery) > 0 { 1772 request.URL.RawQuery = "&" + opQuery 1773 } else { 1774 request.URL.RawQuery = opQuery 1775 } 1776 1777 request.Method = "GET" 1778 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1779 if err != nil { 1780 return out, metadata, &smithy.SerializationError{Err: err} 1781 } 1782 1783 if err := awsRestjson1_serializeOpHttpBindingsListHostedConfigurationVersionsInput(input, restEncoder); err != nil { 1784 return out, metadata, &smithy.SerializationError{Err: err} 1785 } 1786 1787 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1788 return out, metadata, &smithy.SerializationError{Err: err} 1789 } 1790 in.Request = request 1791 1792 return next.HandleSerialize(ctx, in) 1793} 1794func awsRestjson1_serializeOpHttpBindingsListHostedConfigurationVersionsInput(v *ListHostedConfigurationVersionsInput, encoder *httpbinding.Encoder) error { 1795 if v == nil { 1796 return fmt.Errorf("unsupported serialization of nil %T", v) 1797 } 1798 1799 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1800 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1801 } 1802 if v.ApplicationId != nil { 1803 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1804 return err 1805 } 1806 } 1807 1808 if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 { 1809 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")} 1810 } 1811 if v.ConfigurationProfileId != nil { 1812 if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil { 1813 return err 1814 } 1815 } 1816 1817 if v.MaxResults != 0 { 1818 encoder.SetQuery("max_results").Integer(v.MaxResults) 1819 } 1820 1821 if v.NextToken != nil { 1822 encoder.SetQuery("next_token").String(*v.NextToken) 1823 } 1824 1825 return nil 1826} 1827 1828type awsRestjson1_serializeOpListTagsForResource struct { 1829} 1830 1831func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 1832 return "OperationSerializer" 1833} 1834 1835func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1836 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1837) { 1838 request, ok := in.Request.(*smithyhttp.Request) 1839 if !ok { 1840 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1841 } 1842 1843 input, ok := in.Parameters.(*ListTagsForResourceInput) 1844 _ = input 1845 if !ok { 1846 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1847 } 1848 1849 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1850 request.URL.Path = opPath 1851 if len(request.URL.RawQuery) > 0 { 1852 request.URL.RawQuery = "&" + opQuery 1853 } else { 1854 request.URL.RawQuery = opQuery 1855 } 1856 1857 request.Method = "GET" 1858 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1859 if err != nil { 1860 return out, metadata, &smithy.SerializationError{Err: err} 1861 } 1862 1863 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 1864 return out, metadata, &smithy.SerializationError{Err: err} 1865 } 1866 1867 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1868 return out, metadata, &smithy.SerializationError{Err: err} 1869 } 1870 in.Request = request 1871 1872 return next.HandleSerialize(ctx, in) 1873} 1874func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1875 if v == nil { 1876 return fmt.Errorf("unsupported serialization of nil %T", v) 1877 } 1878 1879 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1880 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1881 } 1882 if v.ResourceArn != nil { 1883 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1884 return err 1885 } 1886 } 1887 1888 return nil 1889} 1890 1891type awsRestjson1_serializeOpStartDeployment struct { 1892} 1893 1894func (*awsRestjson1_serializeOpStartDeployment) ID() string { 1895 return "OperationSerializer" 1896} 1897 1898func (m *awsRestjson1_serializeOpStartDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1899 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1900) { 1901 request, ok := in.Request.(*smithyhttp.Request) 1902 if !ok { 1903 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1904 } 1905 1906 input, ok := in.Parameters.(*StartDeploymentInput) 1907 _ = input 1908 if !ok { 1909 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1910 } 1911 1912 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}/deployments") 1913 request.URL.Path = opPath 1914 if len(request.URL.RawQuery) > 0 { 1915 request.URL.RawQuery = "&" + opQuery 1916 } else { 1917 request.URL.RawQuery = opQuery 1918 } 1919 1920 request.Method = "POST" 1921 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1922 if err != nil { 1923 return out, metadata, &smithy.SerializationError{Err: err} 1924 } 1925 1926 if err := awsRestjson1_serializeOpHttpBindingsStartDeploymentInput(input, restEncoder); err != nil { 1927 return out, metadata, &smithy.SerializationError{Err: err} 1928 } 1929 1930 restEncoder.SetHeader("Content-Type").String("application/json") 1931 1932 jsonEncoder := smithyjson.NewEncoder() 1933 if err := awsRestjson1_serializeOpDocumentStartDeploymentInput(input, jsonEncoder.Value); err != nil { 1934 return out, metadata, &smithy.SerializationError{Err: err} 1935 } 1936 1937 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1938 return out, metadata, &smithy.SerializationError{Err: err} 1939 } 1940 1941 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1942 return out, metadata, &smithy.SerializationError{Err: err} 1943 } 1944 in.Request = request 1945 1946 return next.HandleSerialize(ctx, in) 1947} 1948func awsRestjson1_serializeOpHttpBindingsStartDeploymentInput(v *StartDeploymentInput, encoder *httpbinding.Encoder) error { 1949 if v == nil { 1950 return fmt.Errorf("unsupported serialization of nil %T", v) 1951 } 1952 1953 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 1954 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 1955 } 1956 if v.ApplicationId != nil { 1957 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 1958 return err 1959 } 1960 } 1961 1962 if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 { 1963 return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")} 1964 } 1965 if v.EnvironmentId != nil { 1966 if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil { 1967 return err 1968 } 1969 } 1970 1971 return nil 1972} 1973 1974func awsRestjson1_serializeOpDocumentStartDeploymentInput(v *StartDeploymentInput, value smithyjson.Value) error { 1975 object := value.Object() 1976 defer object.Close() 1977 1978 if v.ConfigurationProfileId != nil { 1979 ok := object.Key("ConfigurationProfileId") 1980 ok.String(*v.ConfigurationProfileId) 1981 } 1982 1983 if v.ConfigurationVersion != nil { 1984 ok := object.Key("ConfigurationVersion") 1985 ok.String(*v.ConfigurationVersion) 1986 } 1987 1988 if v.DeploymentStrategyId != nil { 1989 ok := object.Key("DeploymentStrategyId") 1990 ok.String(*v.DeploymentStrategyId) 1991 } 1992 1993 if v.Description != nil { 1994 ok := object.Key("Description") 1995 ok.String(*v.Description) 1996 } 1997 1998 if v.Tags != nil { 1999 ok := object.Key("Tags") 2000 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 2001 return err 2002 } 2003 } 2004 2005 return nil 2006} 2007 2008type awsRestjson1_serializeOpStopDeployment struct { 2009} 2010 2011func (*awsRestjson1_serializeOpStopDeployment) ID() string { 2012 return "OperationSerializer" 2013} 2014 2015func (m *awsRestjson1_serializeOpStopDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2016 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2017) { 2018 request, ok := in.Request.(*smithyhttp.Request) 2019 if !ok { 2020 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2021 } 2022 2023 input, ok := in.Parameters.(*StopDeploymentInput) 2024 _ = input 2025 if !ok { 2026 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2027 } 2028 2029 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}/deployments/{DeploymentNumber}") 2030 request.URL.Path = opPath 2031 if len(request.URL.RawQuery) > 0 { 2032 request.URL.RawQuery = "&" + opQuery 2033 } else { 2034 request.URL.RawQuery = opQuery 2035 } 2036 2037 request.Method = "DELETE" 2038 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2039 if err != nil { 2040 return out, metadata, &smithy.SerializationError{Err: err} 2041 } 2042 2043 if err := awsRestjson1_serializeOpHttpBindingsStopDeploymentInput(input, restEncoder); err != nil { 2044 return out, metadata, &smithy.SerializationError{Err: err} 2045 } 2046 2047 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2048 return out, metadata, &smithy.SerializationError{Err: err} 2049 } 2050 in.Request = request 2051 2052 return next.HandleSerialize(ctx, in) 2053} 2054func awsRestjson1_serializeOpHttpBindingsStopDeploymentInput(v *StopDeploymentInput, encoder *httpbinding.Encoder) error { 2055 if v == nil { 2056 return fmt.Errorf("unsupported serialization of nil %T", v) 2057 } 2058 2059 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 2060 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 2061 } 2062 if v.ApplicationId != nil { 2063 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 2064 return err 2065 } 2066 } 2067 2068 if v.DeploymentNumber == 0 { 2069 return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentNumber must not be empty")} 2070 } 2071 if v.DeploymentNumber != 0 { 2072 if err := encoder.SetURI("DeploymentNumber").Integer(v.DeploymentNumber); err != nil { 2073 return err 2074 } 2075 } 2076 2077 if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 { 2078 return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")} 2079 } 2080 if v.EnvironmentId != nil { 2081 if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil { 2082 return err 2083 } 2084 } 2085 2086 return nil 2087} 2088 2089type awsRestjson1_serializeOpTagResource struct { 2090} 2091 2092func (*awsRestjson1_serializeOpTagResource) ID() string { 2093 return "OperationSerializer" 2094} 2095 2096func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2097 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2098) { 2099 request, ok := in.Request.(*smithyhttp.Request) 2100 if !ok { 2101 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2102 } 2103 2104 input, ok := in.Parameters.(*TagResourceInput) 2105 _ = input 2106 if !ok { 2107 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2108 } 2109 2110 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 2111 request.URL.Path = opPath 2112 if len(request.URL.RawQuery) > 0 { 2113 request.URL.RawQuery = "&" + opQuery 2114 } else { 2115 request.URL.RawQuery = opQuery 2116 } 2117 2118 request.Method = "POST" 2119 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2120 if err != nil { 2121 return out, metadata, &smithy.SerializationError{Err: err} 2122 } 2123 2124 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 2125 return out, metadata, &smithy.SerializationError{Err: err} 2126 } 2127 2128 restEncoder.SetHeader("Content-Type").String("application/json") 2129 2130 jsonEncoder := smithyjson.NewEncoder() 2131 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 2132 return out, metadata, &smithy.SerializationError{Err: err} 2133 } 2134 2135 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2136 return out, metadata, &smithy.SerializationError{Err: err} 2137 } 2138 2139 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2140 return out, metadata, &smithy.SerializationError{Err: err} 2141 } 2142 in.Request = request 2143 2144 return next.HandleSerialize(ctx, in) 2145} 2146func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 2147 if v == nil { 2148 return fmt.Errorf("unsupported serialization of nil %T", v) 2149 } 2150 2151 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 2152 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 2153 } 2154 if v.ResourceArn != nil { 2155 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 2156 return err 2157 } 2158 } 2159 2160 return nil 2161} 2162 2163func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 2164 object := value.Object() 2165 defer object.Close() 2166 2167 if v.Tags != nil { 2168 ok := object.Key("Tags") 2169 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 2170 return err 2171 } 2172 } 2173 2174 return nil 2175} 2176 2177type awsRestjson1_serializeOpUntagResource struct { 2178} 2179 2180func (*awsRestjson1_serializeOpUntagResource) ID() string { 2181 return "OperationSerializer" 2182} 2183 2184func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2185 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2186) { 2187 request, ok := in.Request.(*smithyhttp.Request) 2188 if !ok { 2189 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2190 } 2191 2192 input, ok := in.Parameters.(*UntagResourceInput) 2193 _ = input 2194 if !ok { 2195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2196 } 2197 2198 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 2199 request.URL.Path = opPath 2200 if len(request.URL.RawQuery) > 0 { 2201 request.URL.RawQuery = "&" + opQuery 2202 } else { 2203 request.URL.RawQuery = opQuery 2204 } 2205 2206 request.Method = "DELETE" 2207 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2208 if err != nil { 2209 return out, metadata, &smithy.SerializationError{Err: err} 2210 } 2211 2212 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 2213 return out, metadata, &smithy.SerializationError{Err: err} 2214 } 2215 2216 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2217 return out, metadata, &smithy.SerializationError{Err: err} 2218 } 2219 in.Request = request 2220 2221 return next.HandleSerialize(ctx, in) 2222} 2223func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 2224 if v == nil { 2225 return fmt.Errorf("unsupported serialization of nil %T", v) 2226 } 2227 2228 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 2229 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 2230 } 2231 if v.ResourceArn != nil { 2232 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 2233 return err 2234 } 2235 } 2236 2237 if v.TagKeys != nil { 2238 for i := range v.TagKeys { 2239 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 2240 } 2241 } 2242 2243 return nil 2244} 2245 2246type awsRestjson1_serializeOpUpdateApplication struct { 2247} 2248 2249func (*awsRestjson1_serializeOpUpdateApplication) ID() string { 2250 return "OperationSerializer" 2251} 2252 2253func (m *awsRestjson1_serializeOpUpdateApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2254 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2255) { 2256 request, ok := in.Request.(*smithyhttp.Request) 2257 if !ok { 2258 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2259 } 2260 2261 input, ok := in.Parameters.(*UpdateApplicationInput) 2262 _ = input 2263 if !ok { 2264 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2265 } 2266 2267 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}") 2268 request.URL.Path = opPath 2269 if len(request.URL.RawQuery) > 0 { 2270 request.URL.RawQuery = "&" + opQuery 2271 } else { 2272 request.URL.RawQuery = opQuery 2273 } 2274 2275 request.Method = "PATCH" 2276 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2277 if err != nil { 2278 return out, metadata, &smithy.SerializationError{Err: err} 2279 } 2280 2281 if err := awsRestjson1_serializeOpHttpBindingsUpdateApplicationInput(input, restEncoder); err != nil { 2282 return out, metadata, &smithy.SerializationError{Err: err} 2283 } 2284 2285 restEncoder.SetHeader("Content-Type").String("application/json") 2286 2287 jsonEncoder := smithyjson.NewEncoder() 2288 if err := awsRestjson1_serializeOpDocumentUpdateApplicationInput(input, jsonEncoder.Value); err != nil { 2289 return out, metadata, &smithy.SerializationError{Err: err} 2290 } 2291 2292 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2293 return out, metadata, &smithy.SerializationError{Err: err} 2294 } 2295 2296 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2297 return out, metadata, &smithy.SerializationError{Err: err} 2298 } 2299 in.Request = request 2300 2301 return next.HandleSerialize(ctx, in) 2302} 2303func awsRestjson1_serializeOpHttpBindingsUpdateApplicationInput(v *UpdateApplicationInput, encoder *httpbinding.Encoder) error { 2304 if v == nil { 2305 return fmt.Errorf("unsupported serialization of nil %T", v) 2306 } 2307 2308 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 2309 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 2310 } 2311 if v.ApplicationId != nil { 2312 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 2313 return err 2314 } 2315 } 2316 2317 return nil 2318} 2319 2320func awsRestjson1_serializeOpDocumentUpdateApplicationInput(v *UpdateApplicationInput, value smithyjson.Value) error { 2321 object := value.Object() 2322 defer object.Close() 2323 2324 if v.Description != nil { 2325 ok := object.Key("Description") 2326 ok.String(*v.Description) 2327 } 2328 2329 if v.Name != nil { 2330 ok := object.Key("Name") 2331 ok.String(*v.Name) 2332 } 2333 2334 return nil 2335} 2336 2337type awsRestjson1_serializeOpUpdateConfigurationProfile struct { 2338} 2339 2340func (*awsRestjson1_serializeOpUpdateConfigurationProfile) ID() string { 2341 return "OperationSerializer" 2342} 2343 2344func (m *awsRestjson1_serializeOpUpdateConfigurationProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2345 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2346) { 2347 request, ok := in.Request.(*smithyhttp.Request) 2348 if !ok { 2349 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2350 } 2351 2352 input, ok := in.Parameters.(*UpdateConfigurationProfileInput) 2353 _ = input 2354 if !ok { 2355 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2356 } 2357 2358 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}") 2359 request.URL.Path = opPath 2360 if len(request.URL.RawQuery) > 0 { 2361 request.URL.RawQuery = "&" + opQuery 2362 } else { 2363 request.URL.RawQuery = opQuery 2364 } 2365 2366 request.Method = "PATCH" 2367 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2368 if err != nil { 2369 return out, metadata, &smithy.SerializationError{Err: err} 2370 } 2371 2372 if err := awsRestjson1_serializeOpHttpBindingsUpdateConfigurationProfileInput(input, restEncoder); err != nil { 2373 return out, metadata, &smithy.SerializationError{Err: err} 2374 } 2375 2376 restEncoder.SetHeader("Content-Type").String("application/json") 2377 2378 jsonEncoder := smithyjson.NewEncoder() 2379 if err := awsRestjson1_serializeOpDocumentUpdateConfigurationProfileInput(input, jsonEncoder.Value); err != nil { 2380 return out, metadata, &smithy.SerializationError{Err: err} 2381 } 2382 2383 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2384 return out, metadata, &smithy.SerializationError{Err: err} 2385 } 2386 2387 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2388 return out, metadata, &smithy.SerializationError{Err: err} 2389 } 2390 in.Request = request 2391 2392 return next.HandleSerialize(ctx, in) 2393} 2394func awsRestjson1_serializeOpHttpBindingsUpdateConfigurationProfileInput(v *UpdateConfigurationProfileInput, encoder *httpbinding.Encoder) error { 2395 if v == nil { 2396 return fmt.Errorf("unsupported serialization of nil %T", v) 2397 } 2398 2399 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 2400 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 2401 } 2402 if v.ApplicationId != nil { 2403 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 2404 return err 2405 } 2406 } 2407 2408 if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 { 2409 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")} 2410 } 2411 if v.ConfigurationProfileId != nil { 2412 if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil { 2413 return err 2414 } 2415 } 2416 2417 return nil 2418} 2419 2420func awsRestjson1_serializeOpDocumentUpdateConfigurationProfileInput(v *UpdateConfigurationProfileInput, value smithyjson.Value) error { 2421 object := value.Object() 2422 defer object.Close() 2423 2424 if v.Description != nil { 2425 ok := object.Key("Description") 2426 ok.String(*v.Description) 2427 } 2428 2429 if v.Name != nil { 2430 ok := object.Key("Name") 2431 ok.String(*v.Name) 2432 } 2433 2434 if v.RetrievalRoleArn != nil { 2435 ok := object.Key("RetrievalRoleArn") 2436 ok.String(*v.RetrievalRoleArn) 2437 } 2438 2439 if v.Validators != nil { 2440 ok := object.Key("Validators") 2441 if err := awsRestjson1_serializeDocumentValidatorList(v.Validators, ok); err != nil { 2442 return err 2443 } 2444 } 2445 2446 return nil 2447} 2448 2449type awsRestjson1_serializeOpUpdateDeploymentStrategy struct { 2450} 2451 2452func (*awsRestjson1_serializeOpUpdateDeploymentStrategy) ID() string { 2453 return "OperationSerializer" 2454} 2455 2456func (m *awsRestjson1_serializeOpUpdateDeploymentStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2457 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2458) { 2459 request, ok := in.Request.(*smithyhttp.Request) 2460 if !ok { 2461 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2462 } 2463 2464 input, ok := in.Parameters.(*UpdateDeploymentStrategyInput) 2465 _ = input 2466 if !ok { 2467 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2468 } 2469 2470 opPath, opQuery := httpbinding.SplitURI("/deploymentstrategies/{DeploymentStrategyId}") 2471 request.URL.Path = opPath 2472 if len(request.URL.RawQuery) > 0 { 2473 request.URL.RawQuery = "&" + opQuery 2474 } else { 2475 request.URL.RawQuery = opQuery 2476 } 2477 2478 request.Method = "PATCH" 2479 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2480 if err != nil { 2481 return out, metadata, &smithy.SerializationError{Err: err} 2482 } 2483 2484 if err := awsRestjson1_serializeOpHttpBindingsUpdateDeploymentStrategyInput(input, restEncoder); err != nil { 2485 return out, metadata, &smithy.SerializationError{Err: err} 2486 } 2487 2488 restEncoder.SetHeader("Content-Type").String("application/json") 2489 2490 jsonEncoder := smithyjson.NewEncoder() 2491 if err := awsRestjson1_serializeOpDocumentUpdateDeploymentStrategyInput(input, jsonEncoder.Value); err != nil { 2492 return out, metadata, &smithy.SerializationError{Err: err} 2493 } 2494 2495 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2496 return out, metadata, &smithy.SerializationError{Err: err} 2497 } 2498 2499 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2500 return out, metadata, &smithy.SerializationError{Err: err} 2501 } 2502 in.Request = request 2503 2504 return next.HandleSerialize(ctx, in) 2505} 2506func awsRestjson1_serializeOpHttpBindingsUpdateDeploymentStrategyInput(v *UpdateDeploymentStrategyInput, encoder *httpbinding.Encoder) error { 2507 if v == nil { 2508 return fmt.Errorf("unsupported serialization of nil %T", v) 2509 } 2510 2511 if v.DeploymentStrategyId == nil || len(*v.DeploymentStrategyId) == 0 { 2512 return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentStrategyId must not be empty")} 2513 } 2514 if v.DeploymentStrategyId != nil { 2515 if err := encoder.SetURI("DeploymentStrategyId").String(*v.DeploymentStrategyId); err != nil { 2516 return err 2517 } 2518 } 2519 2520 return nil 2521} 2522 2523func awsRestjson1_serializeOpDocumentUpdateDeploymentStrategyInput(v *UpdateDeploymentStrategyInput, value smithyjson.Value) error { 2524 object := value.Object() 2525 defer object.Close() 2526 2527 if v.DeploymentDurationInMinutes != 0 { 2528 ok := object.Key("DeploymentDurationInMinutes") 2529 ok.Integer(v.DeploymentDurationInMinutes) 2530 } 2531 2532 if v.Description != nil { 2533 ok := object.Key("Description") 2534 ok.String(*v.Description) 2535 } 2536 2537 if v.FinalBakeTimeInMinutes != 0 { 2538 ok := object.Key("FinalBakeTimeInMinutes") 2539 ok.Integer(v.FinalBakeTimeInMinutes) 2540 } 2541 2542 if v.GrowthFactor != 0 { 2543 ok := object.Key("GrowthFactor") 2544 ok.Float(v.GrowthFactor) 2545 } 2546 2547 if len(v.GrowthType) > 0 { 2548 ok := object.Key("GrowthType") 2549 ok.String(string(v.GrowthType)) 2550 } 2551 2552 return nil 2553} 2554 2555type awsRestjson1_serializeOpUpdateEnvironment struct { 2556} 2557 2558func (*awsRestjson1_serializeOpUpdateEnvironment) ID() string { 2559 return "OperationSerializer" 2560} 2561 2562func (m *awsRestjson1_serializeOpUpdateEnvironment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2563 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2564) { 2565 request, ok := in.Request.(*smithyhttp.Request) 2566 if !ok { 2567 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2568 } 2569 2570 input, ok := in.Parameters.(*UpdateEnvironmentInput) 2571 _ = input 2572 if !ok { 2573 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2574 } 2575 2576 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/environments/{EnvironmentId}") 2577 request.URL.Path = opPath 2578 if len(request.URL.RawQuery) > 0 { 2579 request.URL.RawQuery = "&" + opQuery 2580 } else { 2581 request.URL.RawQuery = opQuery 2582 } 2583 2584 request.Method = "PATCH" 2585 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2586 if err != nil { 2587 return out, metadata, &smithy.SerializationError{Err: err} 2588 } 2589 2590 if err := awsRestjson1_serializeOpHttpBindingsUpdateEnvironmentInput(input, restEncoder); err != nil { 2591 return out, metadata, &smithy.SerializationError{Err: err} 2592 } 2593 2594 restEncoder.SetHeader("Content-Type").String("application/json") 2595 2596 jsonEncoder := smithyjson.NewEncoder() 2597 if err := awsRestjson1_serializeOpDocumentUpdateEnvironmentInput(input, jsonEncoder.Value); err != nil { 2598 return out, metadata, &smithy.SerializationError{Err: err} 2599 } 2600 2601 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2602 return out, metadata, &smithy.SerializationError{Err: err} 2603 } 2604 2605 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2606 return out, metadata, &smithy.SerializationError{Err: err} 2607 } 2608 in.Request = request 2609 2610 return next.HandleSerialize(ctx, in) 2611} 2612func awsRestjson1_serializeOpHttpBindingsUpdateEnvironmentInput(v *UpdateEnvironmentInput, encoder *httpbinding.Encoder) error { 2613 if v == nil { 2614 return fmt.Errorf("unsupported serialization of nil %T", v) 2615 } 2616 2617 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 2618 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 2619 } 2620 if v.ApplicationId != nil { 2621 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 2622 return err 2623 } 2624 } 2625 2626 if v.EnvironmentId == nil || len(*v.EnvironmentId) == 0 { 2627 return &smithy.SerializationError{Err: fmt.Errorf("input member EnvironmentId must not be empty")} 2628 } 2629 if v.EnvironmentId != nil { 2630 if err := encoder.SetURI("EnvironmentId").String(*v.EnvironmentId); err != nil { 2631 return err 2632 } 2633 } 2634 2635 return nil 2636} 2637 2638func awsRestjson1_serializeOpDocumentUpdateEnvironmentInput(v *UpdateEnvironmentInput, value smithyjson.Value) error { 2639 object := value.Object() 2640 defer object.Close() 2641 2642 if v.Description != nil { 2643 ok := object.Key("Description") 2644 ok.String(*v.Description) 2645 } 2646 2647 if v.Monitors != nil { 2648 ok := object.Key("Monitors") 2649 if err := awsRestjson1_serializeDocumentMonitorList(v.Monitors, ok); err != nil { 2650 return err 2651 } 2652 } 2653 2654 if v.Name != nil { 2655 ok := object.Key("Name") 2656 ok.String(*v.Name) 2657 } 2658 2659 return nil 2660} 2661 2662type awsRestjson1_serializeOpValidateConfiguration struct { 2663} 2664 2665func (*awsRestjson1_serializeOpValidateConfiguration) ID() string { 2666 return "OperationSerializer" 2667} 2668 2669func (m *awsRestjson1_serializeOpValidateConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2670 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2671) { 2672 request, ok := in.Request.(*smithyhttp.Request) 2673 if !ok { 2674 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2675 } 2676 2677 input, ok := in.Parameters.(*ValidateConfigurationInput) 2678 _ = input 2679 if !ok { 2680 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2681 } 2682 2683 opPath, opQuery := httpbinding.SplitURI("/applications/{ApplicationId}/configurationprofiles/{ConfigurationProfileId}/validators") 2684 request.URL.Path = opPath 2685 if len(request.URL.RawQuery) > 0 { 2686 request.URL.RawQuery = "&" + opQuery 2687 } else { 2688 request.URL.RawQuery = opQuery 2689 } 2690 2691 request.Method = "POST" 2692 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2693 if err != nil { 2694 return out, metadata, &smithy.SerializationError{Err: err} 2695 } 2696 2697 if err := awsRestjson1_serializeOpHttpBindingsValidateConfigurationInput(input, restEncoder); err != nil { 2698 return out, metadata, &smithy.SerializationError{Err: err} 2699 } 2700 2701 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2702 return out, metadata, &smithy.SerializationError{Err: err} 2703 } 2704 in.Request = request 2705 2706 return next.HandleSerialize(ctx, in) 2707} 2708func awsRestjson1_serializeOpHttpBindingsValidateConfigurationInput(v *ValidateConfigurationInput, encoder *httpbinding.Encoder) error { 2709 if v == nil { 2710 return fmt.Errorf("unsupported serialization of nil %T", v) 2711 } 2712 2713 if v.ApplicationId == nil || len(*v.ApplicationId) == 0 { 2714 return &smithy.SerializationError{Err: fmt.Errorf("input member ApplicationId must not be empty")} 2715 } 2716 if v.ApplicationId != nil { 2717 if err := encoder.SetURI("ApplicationId").String(*v.ApplicationId); err != nil { 2718 return err 2719 } 2720 } 2721 2722 if v.ConfigurationProfileId == nil || len(*v.ConfigurationProfileId) == 0 { 2723 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationProfileId must not be empty")} 2724 } 2725 if v.ConfigurationProfileId != nil { 2726 if err := encoder.SetURI("ConfigurationProfileId").String(*v.ConfigurationProfileId); err != nil { 2727 return err 2728 } 2729 } 2730 2731 if v.ConfigurationVersion != nil { 2732 encoder.SetQuery("configuration_version").String(*v.ConfigurationVersion) 2733 } 2734 2735 return nil 2736} 2737 2738func awsRestjson1_serializeDocumentMonitor(v *types.Monitor, value smithyjson.Value) error { 2739 object := value.Object() 2740 defer object.Close() 2741 2742 if v.AlarmArn != nil { 2743 ok := object.Key("AlarmArn") 2744 ok.String(*v.AlarmArn) 2745 } 2746 2747 if v.AlarmRoleArn != nil { 2748 ok := object.Key("AlarmRoleArn") 2749 ok.String(*v.AlarmRoleArn) 2750 } 2751 2752 return nil 2753} 2754 2755func awsRestjson1_serializeDocumentMonitorList(v []types.Monitor, value smithyjson.Value) error { 2756 array := value.Array() 2757 defer array.Close() 2758 2759 for i := range v { 2760 av := array.Value() 2761 if err := awsRestjson1_serializeDocumentMonitor(&v[i], av); err != nil { 2762 return err 2763 } 2764 } 2765 return nil 2766} 2767 2768func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 2769 object := value.Object() 2770 defer object.Close() 2771 2772 for key := range v { 2773 om := object.Key(key) 2774 om.String(v[key]) 2775 } 2776 return nil 2777} 2778 2779func awsRestjson1_serializeDocumentValidator(v *types.Validator, value smithyjson.Value) error { 2780 object := value.Object() 2781 defer object.Close() 2782 2783 if v.Content != nil { 2784 ok := object.Key("Content") 2785 ok.String(*v.Content) 2786 } 2787 2788 if len(v.Type) > 0 { 2789 ok := object.Key("Type") 2790 ok.String(string(v.Type)) 2791 } 2792 2793 return nil 2794} 2795 2796func awsRestjson1_serializeDocumentValidatorList(v []types.Validator, value smithyjson.Value) error { 2797 array := value.Array() 2798 defer array.Close() 2799 2800 for i := range v { 2801 av := array.Value() 2802 if err := awsRestjson1_serializeDocumentValidator(&v[i], av); err != nil { 2803 return err 2804 } 2805 } 2806 return nil 2807} 2808