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