1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package mq 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/mq/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_serializeOpCreateBroker struct { 18} 19 20func (*awsRestjson1_serializeOpCreateBroker) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpCreateBroker) 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.(*CreateBrokerInput) 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("/v1/brokers") 39 request.URL.Path = opPath 40 if len(request.URL.RawQuery) > 0 { 41 request.URL.RawQuery = "&" + opQuery 42 } else { 43 request.URL.RawQuery = opQuery 44 } 45 46 request.Method = "POST" 47 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 48 if err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 restEncoder.SetHeader("Content-Type").String("application/json") 53 54 jsonEncoder := smithyjson.NewEncoder() 55 if err := awsRestjson1_serializeOpDocumentCreateBrokerInput(input, jsonEncoder.Value); err != nil { 56 return out, metadata, &smithy.SerializationError{Err: err} 57 } 58 59 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 63 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 64 return out, metadata, &smithy.SerializationError{Err: err} 65 } 66 in.Request = request 67 68 return next.HandleSerialize(ctx, in) 69} 70func awsRestjson1_serializeOpHttpBindingsCreateBrokerInput(v *CreateBrokerInput, encoder *httpbinding.Encoder) error { 71 if v == nil { 72 return fmt.Errorf("unsupported serialization of nil %T", v) 73 } 74 75 return nil 76} 77 78func awsRestjson1_serializeOpDocumentCreateBrokerInput(v *CreateBrokerInput, value smithyjson.Value) error { 79 object := value.Object() 80 defer object.Close() 81 82 if len(v.AuthenticationStrategy) > 0 { 83 ok := object.Key("authenticationStrategy") 84 ok.String(string(v.AuthenticationStrategy)) 85 } 86 87 if v.AutoMinorVersionUpgrade { 88 ok := object.Key("autoMinorVersionUpgrade") 89 ok.Boolean(v.AutoMinorVersionUpgrade) 90 } 91 92 if v.BrokerName != nil { 93 ok := object.Key("brokerName") 94 ok.String(*v.BrokerName) 95 } 96 97 if v.Configuration != nil { 98 ok := object.Key("configuration") 99 if err := awsRestjson1_serializeDocumentConfigurationId(v.Configuration, ok); err != nil { 100 return err 101 } 102 } 103 104 if v.CreatorRequestId != nil { 105 ok := object.Key("creatorRequestId") 106 ok.String(*v.CreatorRequestId) 107 } 108 109 if len(v.DeploymentMode) > 0 { 110 ok := object.Key("deploymentMode") 111 ok.String(string(v.DeploymentMode)) 112 } 113 114 if v.EncryptionOptions != nil { 115 ok := object.Key("encryptionOptions") 116 if err := awsRestjson1_serializeDocumentEncryptionOptions(v.EncryptionOptions, ok); err != nil { 117 return err 118 } 119 } 120 121 if len(v.EngineType) > 0 { 122 ok := object.Key("engineType") 123 ok.String(string(v.EngineType)) 124 } 125 126 if v.EngineVersion != nil { 127 ok := object.Key("engineVersion") 128 ok.String(*v.EngineVersion) 129 } 130 131 if v.HostInstanceType != nil { 132 ok := object.Key("hostInstanceType") 133 ok.String(*v.HostInstanceType) 134 } 135 136 if v.LdapServerMetadata != nil { 137 ok := object.Key("ldapServerMetadata") 138 if err := awsRestjson1_serializeDocumentLdapServerMetadataInput(v.LdapServerMetadata, ok); err != nil { 139 return err 140 } 141 } 142 143 if v.Logs != nil { 144 ok := object.Key("logs") 145 if err := awsRestjson1_serializeDocumentLogs(v.Logs, ok); err != nil { 146 return err 147 } 148 } 149 150 if v.MaintenanceWindowStartTime != nil { 151 ok := object.Key("maintenanceWindowStartTime") 152 if err := awsRestjson1_serializeDocumentWeeklyStartTime(v.MaintenanceWindowStartTime, ok); err != nil { 153 return err 154 } 155 } 156 157 if v.PubliclyAccessible { 158 ok := object.Key("publiclyAccessible") 159 ok.Boolean(v.PubliclyAccessible) 160 } 161 162 if v.SecurityGroups != nil { 163 ok := object.Key("securityGroups") 164 if err := awsRestjson1_serializeDocument__listOf__string(v.SecurityGroups, ok); err != nil { 165 return err 166 } 167 } 168 169 if len(v.StorageType) > 0 { 170 ok := object.Key("storageType") 171 ok.String(string(v.StorageType)) 172 } 173 174 if v.SubnetIds != nil { 175 ok := object.Key("subnetIds") 176 if err := awsRestjson1_serializeDocument__listOf__string(v.SubnetIds, ok); err != nil { 177 return err 178 } 179 } 180 181 if v.Tags != nil { 182 ok := object.Key("tags") 183 if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil { 184 return err 185 } 186 } 187 188 if v.Users != nil { 189 ok := object.Key("users") 190 if err := awsRestjson1_serializeDocument__listOfUser(v.Users, ok); err != nil { 191 return err 192 } 193 } 194 195 return nil 196} 197 198type awsRestjson1_serializeOpCreateConfiguration struct { 199} 200 201func (*awsRestjson1_serializeOpCreateConfiguration) ID() string { 202 return "OperationSerializer" 203} 204 205func (m *awsRestjson1_serializeOpCreateConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 206 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 207) { 208 request, ok := in.Request.(*smithyhttp.Request) 209 if !ok { 210 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 211 } 212 213 input, ok := in.Parameters.(*CreateConfigurationInput) 214 _ = input 215 if !ok { 216 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 217 } 218 219 opPath, opQuery := httpbinding.SplitURI("/v1/configurations") 220 request.URL.Path = opPath 221 if len(request.URL.RawQuery) > 0 { 222 request.URL.RawQuery = "&" + opQuery 223 } else { 224 request.URL.RawQuery = opQuery 225 } 226 227 request.Method = "POST" 228 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 229 if err != nil { 230 return out, metadata, &smithy.SerializationError{Err: err} 231 } 232 233 restEncoder.SetHeader("Content-Type").String("application/json") 234 235 jsonEncoder := smithyjson.NewEncoder() 236 if err := awsRestjson1_serializeOpDocumentCreateConfigurationInput(input, jsonEncoder.Value); err != nil { 237 return out, metadata, &smithy.SerializationError{Err: err} 238 } 239 240 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 241 return out, metadata, &smithy.SerializationError{Err: err} 242 } 243 244 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 245 return out, metadata, &smithy.SerializationError{Err: err} 246 } 247 in.Request = request 248 249 return next.HandleSerialize(ctx, in) 250} 251func awsRestjson1_serializeOpHttpBindingsCreateConfigurationInput(v *CreateConfigurationInput, encoder *httpbinding.Encoder) error { 252 if v == nil { 253 return fmt.Errorf("unsupported serialization of nil %T", v) 254 } 255 256 return nil 257} 258 259func awsRestjson1_serializeOpDocumentCreateConfigurationInput(v *CreateConfigurationInput, value smithyjson.Value) error { 260 object := value.Object() 261 defer object.Close() 262 263 if len(v.AuthenticationStrategy) > 0 { 264 ok := object.Key("authenticationStrategy") 265 ok.String(string(v.AuthenticationStrategy)) 266 } 267 268 if len(v.EngineType) > 0 { 269 ok := object.Key("engineType") 270 ok.String(string(v.EngineType)) 271 } 272 273 if v.EngineVersion != nil { 274 ok := object.Key("engineVersion") 275 ok.String(*v.EngineVersion) 276 } 277 278 if v.Name != nil { 279 ok := object.Key("name") 280 ok.String(*v.Name) 281 } 282 283 if v.Tags != nil { 284 ok := object.Key("tags") 285 if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil { 286 return err 287 } 288 } 289 290 return nil 291} 292 293type awsRestjson1_serializeOpCreateTags struct { 294} 295 296func (*awsRestjson1_serializeOpCreateTags) ID() string { 297 return "OperationSerializer" 298} 299 300func (m *awsRestjson1_serializeOpCreateTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 301 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 302) { 303 request, ok := in.Request.(*smithyhttp.Request) 304 if !ok { 305 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 306 } 307 308 input, ok := in.Parameters.(*CreateTagsInput) 309 _ = input 310 if !ok { 311 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 312 } 313 314 opPath, opQuery := httpbinding.SplitURI("/v1/tags/{ResourceArn}") 315 request.URL.Path = opPath 316 if len(request.URL.RawQuery) > 0 { 317 request.URL.RawQuery = "&" + opQuery 318 } else { 319 request.URL.RawQuery = opQuery 320 } 321 322 request.Method = "POST" 323 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 324 if err != nil { 325 return out, metadata, &smithy.SerializationError{Err: err} 326 } 327 328 if err := awsRestjson1_serializeOpHttpBindingsCreateTagsInput(input, restEncoder); err != nil { 329 return out, metadata, &smithy.SerializationError{Err: err} 330 } 331 332 restEncoder.SetHeader("Content-Type").String("application/json") 333 334 jsonEncoder := smithyjson.NewEncoder() 335 if err := awsRestjson1_serializeOpDocumentCreateTagsInput(input, jsonEncoder.Value); err != nil { 336 return out, metadata, &smithy.SerializationError{Err: err} 337 } 338 339 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 340 return out, metadata, &smithy.SerializationError{Err: err} 341 } 342 343 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 344 return out, metadata, &smithy.SerializationError{Err: err} 345 } 346 in.Request = request 347 348 return next.HandleSerialize(ctx, in) 349} 350func awsRestjson1_serializeOpHttpBindingsCreateTagsInput(v *CreateTagsInput, encoder *httpbinding.Encoder) error { 351 if v == nil { 352 return fmt.Errorf("unsupported serialization of nil %T", v) 353 } 354 355 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 356 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 357 } 358 if v.ResourceArn != nil { 359 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 360 return err 361 } 362 } 363 364 return nil 365} 366 367func awsRestjson1_serializeOpDocumentCreateTagsInput(v *CreateTagsInput, value smithyjson.Value) error { 368 object := value.Object() 369 defer object.Close() 370 371 if v.Tags != nil { 372 ok := object.Key("tags") 373 if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil { 374 return err 375 } 376 } 377 378 return nil 379} 380 381type awsRestjson1_serializeOpCreateUser struct { 382} 383 384func (*awsRestjson1_serializeOpCreateUser) ID() string { 385 return "OperationSerializer" 386} 387 388func (m *awsRestjson1_serializeOpCreateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 389 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 390) { 391 request, ok := in.Request.(*smithyhttp.Request) 392 if !ok { 393 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 394 } 395 396 input, ok := in.Parameters.(*CreateUserInput) 397 _ = input 398 if !ok { 399 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 400 } 401 402 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}/users/{Username}") 403 request.URL.Path = opPath 404 if len(request.URL.RawQuery) > 0 { 405 request.URL.RawQuery = "&" + opQuery 406 } else { 407 request.URL.RawQuery = opQuery 408 } 409 410 request.Method = "POST" 411 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 412 if err != nil { 413 return out, metadata, &smithy.SerializationError{Err: err} 414 } 415 416 if err := awsRestjson1_serializeOpHttpBindingsCreateUserInput(input, restEncoder); err != nil { 417 return out, metadata, &smithy.SerializationError{Err: err} 418 } 419 420 restEncoder.SetHeader("Content-Type").String("application/json") 421 422 jsonEncoder := smithyjson.NewEncoder() 423 if err := awsRestjson1_serializeOpDocumentCreateUserInput(input, jsonEncoder.Value); err != nil { 424 return out, metadata, &smithy.SerializationError{Err: err} 425 } 426 427 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 428 return out, metadata, &smithy.SerializationError{Err: err} 429 } 430 431 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 432 return out, metadata, &smithy.SerializationError{Err: err} 433 } 434 in.Request = request 435 436 return next.HandleSerialize(ctx, in) 437} 438func awsRestjson1_serializeOpHttpBindingsCreateUserInput(v *CreateUserInput, encoder *httpbinding.Encoder) error { 439 if v == nil { 440 return fmt.Errorf("unsupported serialization of nil %T", v) 441 } 442 443 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 444 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 445 } 446 if v.BrokerId != nil { 447 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 448 return err 449 } 450 } 451 452 if v.Username == nil || len(*v.Username) == 0 { 453 return &smithy.SerializationError{Err: fmt.Errorf("input member Username must not be empty")} 454 } 455 if v.Username != nil { 456 if err := encoder.SetURI("Username").String(*v.Username); err != nil { 457 return err 458 } 459 } 460 461 return nil 462} 463 464func awsRestjson1_serializeOpDocumentCreateUserInput(v *CreateUserInput, value smithyjson.Value) error { 465 object := value.Object() 466 defer object.Close() 467 468 if v.ConsoleAccess { 469 ok := object.Key("consoleAccess") 470 ok.Boolean(v.ConsoleAccess) 471 } 472 473 if v.Groups != nil { 474 ok := object.Key("groups") 475 if err := awsRestjson1_serializeDocument__listOf__string(v.Groups, ok); err != nil { 476 return err 477 } 478 } 479 480 if v.Password != nil { 481 ok := object.Key("password") 482 ok.String(*v.Password) 483 } 484 485 return nil 486} 487 488type awsRestjson1_serializeOpDeleteBroker struct { 489} 490 491func (*awsRestjson1_serializeOpDeleteBroker) ID() string { 492 return "OperationSerializer" 493} 494 495func (m *awsRestjson1_serializeOpDeleteBroker) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 496 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 497) { 498 request, ok := in.Request.(*smithyhttp.Request) 499 if !ok { 500 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 501 } 502 503 input, ok := in.Parameters.(*DeleteBrokerInput) 504 _ = input 505 if !ok { 506 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 507 } 508 509 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}") 510 request.URL.Path = opPath 511 if len(request.URL.RawQuery) > 0 { 512 request.URL.RawQuery = "&" + opQuery 513 } else { 514 request.URL.RawQuery = opQuery 515 } 516 517 request.Method = "DELETE" 518 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 519 if err != nil { 520 return out, metadata, &smithy.SerializationError{Err: err} 521 } 522 523 if err := awsRestjson1_serializeOpHttpBindingsDeleteBrokerInput(input, restEncoder); err != nil { 524 return out, metadata, &smithy.SerializationError{Err: err} 525 } 526 527 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 528 return out, metadata, &smithy.SerializationError{Err: err} 529 } 530 in.Request = request 531 532 return next.HandleSerialize(ctx, in) 533} 534func awsRestjson1_serializeOpHttpBindingsDeleteBrokerInput(v *DeleteBrokerInput, encoder *httpbinding.Encoder) error { 535 if v == nil { 536 return fmt.Errorf("unsupported serialization of nil %T", v) 537 } 538 539 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 540 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 541 } 542 if v.BrokerId != nil { 543 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 544 return err 545 } 546 } 547 548 return nil 549} 550 551type awsRestjson1_serializeOpDeleteTags struct { 552} 553 554func (*awsRestjson1_serializeOpDeleteTags) ID() string { 555 return "OperationSerializer" 556} 557 558func (m *awsRestjson1_serializeOpDeleteTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 559 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 560) { 561 request, ok := in.Request.(*smithyhttp.Request) 562 if !ok { 563 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 564 } 565 566 input, ok := in.Parameters.(*DeleteTagsInput) 567 _ = input 568 if !ok { 569 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 570 } 571 572 opPath, opQuery := httpbinding.SplitURI("/v1/tags/{ResourceArn}") 573 request.URL.Path = opPath 574 if len(request.URL.RawQuery) > 0 { 575 request.URL.RawQuery = "&" + opQuery 576 } else { 577 request.URL.RawQuery = opQuery 578 } 579 580 request.Method = "DELETE" 581 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 582 if err != nil { 583 return out, metadata, &smithy.SerializationError{Err: err} 584 } 585 586 if err := awsRestjson1_serializeOpHttpBindingsDeleteTagsInput(input, restEncoder); err != nil { 587 return out, metadata, &smithy.SerializationError{Err: err} 588 } 589 590 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 591 return out, metadata, &smithy.SerializationError{Err: err} 592 } 593 in.Request = request 594 595 return next.HandleSerialize(ctx, in) 596} 597func awsRestjson1_serializeOpHttpBindingsDeleteTagsInput(v *DeleteTagsInput, encoder *httpbinding.Encoder) error { 598 if v == nil { 599 return fmt.Errorf("unsupported serialization of nil %T", v) 600 } 601 602 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 603 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 604 } 605 if v.ResourceArn != nil { 606 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 607 return err 608 } 609 } 610 611 if v.TagKeys != nil { 612 for i := range v.TagKeys { 613 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 614 } 615 } 616 617 return nil 618} 619 620type awsRestjson1_serializeOpDeleteUser struct { 621} 622 623func (*awsRestjson1_serializeOpDeleteUser) ID() string { 624 return "OperationSerializer" 625} 626 627func (m *awsRestjson1_serializeOpDeleteUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 628 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 629) { 630 request, ok := in.Request.(*smithyhttp.Request) 631 if !ok { 632 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 633 } 634 635 input, ok := in.Parameters.(*DeleteUserInput) 636 _ = input 637 if !ok { 638 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 639 } 640 641 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}/users/{Username}") 642 request.URL.Path = opPath 643 if len(request.URL.RawQuery) > 0 { 644 request.URL.RawQuery = "&" + opQuery 645 } else { 646 request.URL.RawQuery = opQuery 647 } 648 649 request.Method = "DELETE" 650 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 651 if err != nil { 652 return out, metadata, &smithy.SerializationError{Err: err} 653 } 654 655 if err := awsRestjson1_serializeOpHttpBindingsDeleteUserInput(input, restEncoder); err != nil { 656 return out, metadata, &smithy.SerializationError{Err: err} 657 } 658 659 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 660 return out, metadata, &smithy.SerializationError{Err: err} 661 } 662 in.Request = request 663 664 return next.HandleSerialize(ctx, in) 665} 666func awsRestjson1_serializeOpHttpBindingsDeleteUserInput(v *DeleteUserInput, encoder *httpbinding.Encoder) error { 667 if v == nil { 668 return fmt.Errorf("unsupported serialization of nil %T", v) 669 } 670 671 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 672 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 673 } 674 if v.BrokerId != nil { 675 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 676 return err 677 } 678 } 679 680 if v.Username == nil || len(*v.Username) == 0 { 681 return &smithy.SerializationError{Err: fmt.Errorf("input member Username must not be empty")} 682 } 683 if v.Username != nil { 684 if err := encoder.SetURI("Username").String(*v.Username); err != nil { 685 return err 686 } 687 } 688 689 return nil 690} 691 692type awsRestjson1_serializeOpDescribeBroker struct { 693} 694 695func (*awsRestjson1_serializeOpDescribeBroker) ID() string { 696 return "OperationSerializer" 697} 698 699func (m *awsRestjson1_serializeOpDescribeBroker) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 700 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 701) { 702 request, ok := in.Request.(*smithyhttp.Request) 703 if !ok { 704 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 705 } 706 707 input, ok := in.Parameters.(*DescribeBrokerInput) 708 _ = input 709 if !ok { 710 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 711 } 712 713 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}") 714 request.URL.Path = opPath 715 if len(request.URL.RawQuery) > 0 { 716 request.URL.RawQuery = "&" + opQuery 717 } else { 718 request.URL.RawQuery = opQuery 719 } 720 721 request.Method = "GET" 722 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 723 if err != nil { 724 return out, metadata, &smithy.SerializationError{Err: err} 725 } 726 727 if err := awsRestjson1_serializeOpHttpBindingsDescribeBrokerInput(input, restEncoder); err != nil { 728 return out, metadata, &smithy.SerializationError{Err: err} 729 } 730 731 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 732 return out, metadata, &smithy.SerializationError{Err: err} 733 } 734 in.Request = request 735 736 return next.HandleSerialize(ctx, in) 737} 738func awsRestjson1_serializeOpHttpBindingsDescribeBrokerInput(v *DescribeBrokerInput, encoder *httpbinding.Encoder) error { 739 if v == nil { 740 return fmt.Errorf("unsupported serialization of nil %T", v) 741 } 742 743 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 744 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 745 } 746 if v.BrokerId != nil { 747 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 748 return err 749 } 750 } 751 752 return nil 753} 754 755type awsRestjson1_serializeOpDescribeBrokerEngineTypes struct { 756} 757 758func (*awsRestjson1_serializeOpDescribeBrokerEngineTypes) ID() string { 759 return "OperationSerializer" 760} 761 762func (m *awsRestjson1_serializeOpDescribeBrokerEngineTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 763 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 764) { 765 request, ok := in.Request.(*smithyhttp.Request) 766 if !ok { 767 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 768 } 769 770 input, ok := in.Parameters.(*DescribeBrokerEngineTypesInput) 771 _ = input 772 if !ok { 773 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 774 } 775 776 opPath, opQuery := httpbinding.SplitURI("/v1/broker-engine-types") 777 request.URL.Path = opPath 778 if len(request.URL.RawQuery) > 0 { 779 request.URL.RawQuery = "&" + opQuery 780 } else { 781 request.URL.RawQuery = opQuery 782 } 783 784 request.Method = "GET" 785 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 786 if err != nil { 787 return out, metadata, &smithy.SerializationError{Err: err} 788 } 789 790 if err := awsRestjson1_serializeOpHttpBindingsDescribeBrokerEngineTypesInput(input, restEncoder); err != nil { 791 return out, metadata, &smithy.SerializationError{Err: err} 792 } 793 794 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 795 return out, metadata, &smithy.SerializationError{Err: err} 796 } 797 in.Request = request 798 799 return next.HandleSerialize(ctx, in) 800} 801func awsRestjson1_serializeOpHttpBindingsDescribeBrokerEngineTypesInput(v *DescribeBrokerEngineTypesInput, encoder *httpbinding.Encoder) error { 802 if v == nil { 803 return fmt.Errorf("unsupported serialization of nil %T", v) 804 } 805 806 if v.EngineType != nil { 807 encoder.SetQuery("engineType").String(*v.EngineType) 808 } 809 810 if v.MaxResults != 0 { 811 encoder.SetQuery("maxResults").Integer(v.MaxResults) 812 } 813 814 if v.NextToken != nil { 815 encoder.SetQuery("nextToken").String(*v.NextToken) 816 } 817 818 return nil 819} 820 821type awsRestjson1_serializeOpDescribeBrokerInstanceOptions struct { 822} 823 824func (*awsRestjson1_serializeOpDescribeBrokerInstanceOptions) ID() string { 825 return "OperationSerializer" 826} 827 828func (m *awsRestjson1_serializeOpDescribeBrokerInstanceOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 829 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 830) { 831 request, ok := in.Request.(*smithyhttp.Request) 832 if !ok { 833 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 834 } 835 836 input, ok := in.Parameters.(*DescribeBrokerInstanceOptionsInput) 837 _ = input 838 if !ok { 839 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 840 } 841 842 opPath, opQuery := httpbinding.SplitURI("/v1/broker-instance-options") 843 request.URL.Path = opPath 844 if len(request.URL.RawQuery) > 0 { 845 request.URL.RawQuery = "&" + opQuery 846 } else { 847 request.URL.RawQuery = opQuery 848 } 849 850 request.Method = "GET" 851 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 852 if err != nil { 853 return out, metadata, &smithy.SerializationError{Err: err} 854 } 855 856 if err := awsRestjson1_serializeOpHttpBindingsDescribeBrokerInstanceOptionsInput(input, restEncoder); err != nil { 857 return out, metadata, &smithy.SerializationError{Err: err} 858 } 859 860 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 861 return out, metadata, &smithy.SerializationError{Err: err} 862 } 863 in.Request = request 864 865 return next.HandleSerialize(ctx, in) 866} 867func awsRestjson1_serializeOpHttpBindingsDescribeBrokerInstanceOptionsInput(v *DescribeBrokerInstanceOptionsInput, encoder *httpbinding.Encoder) error { 868 if v == nil { 869 return fmt.Errorf("unsupported serialization of nil %T", v) 870 } 871 872 if v.EngineType != nil { 873 encoder.SetQuery("engineType").String(*v.EngineType) 874 } 875 876 if v.HostInstanceType != nil { 877 encoder.SetQuery("hostInstanceType").String(*v.HostInstanceType) 878 } 879 880 if v.MaxResults != 0 { 881 encoder.SetQuery("maxResults").Integer(v.MaxResults) 882 } 883 884 if v.NextToken != nil { 885 encoder.SetQuery("nextToken").String(*v.NextToken) 886 } 887 888 if v.StorageType != nil { 889 encoder.SetQuery("storageType").String(*v.StorageType) 890 } 891 892 return nil 893} 894 895type awsRestjson1_serializeOpDescribeConfiguration struct { 896} 897 898func (*awsRestjson1_serializeOpDescribeConfiguration) ID() string { 899 return "OperationSerializer" 900} 901 902func (m *awsRestjson1_serializeOpDescribeConfiguration) 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.(*DescribeConfigurationInput) 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("/v1/configurations/{ConfigurationId}") 917 request.URL.Path = opPath 918 if len(request.URL.RawQuery) > 0 { 919 request.URL.RawQuery = "&" + opQuery 920 } else { 921 request.URL.RawQuery = opQuery 922 } 923 924 request.Method = "GET" 925 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 926 if err != nil { 927 return out, metadata, &smithy.SerializationError{Err: err} 928 } 929 930 if err := awsRestjson1_serializeOpHttpBindingsDescribeConfigurationInput(input, restEncoder); err != nil { 931 return out, metadata, &smithy.SerializationError{Err: err} 932 } 933 934 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 935 return out, metadata, &smithy.SerializationError{Err: err} 936 } 937 in.Request = request 938 939 return next.HandleSerialize(ctx, in) 940} 941func awsRestjson1_serializeOpHttpBindingsDescribeConfigurationInput(v *DescribeConfigurationInput, encoder *httpbinding.Encoder) error { 942 if v == nil { 943 return fmt.Errorf("unsupported serialization of nil %T", v) 944 } 945 946 if v.ConfigurationId == nil || len(*v.ConfigurationId) == 0 { 947 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationId must not be empty")} 948 } 949 if v.ConfigurationId != nil { 950 if err := encoder.SetURI("ConfigurationId").String(*v.ConfigurationId); err != nil { 951 return err 952 } 953 } 954 955 return nil 956} 957 958type awsRestjson1_serializeOpDescribeConfigurationRevision struct { 959} 960 961func (*awsRestjson1_serializeOpDescribeConfigurationRevision) ID() string { 962 return "OperationSerializer" 963} 964 965func (m *awsRestjson1_serializeOpDescribeConfigurationRevision) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 966 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 967) { 968 request, ok := in.Request.(*smithyhttp.Request) 969 if !ok { 970 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 971 } 972 973 input, ok := in.Parameters.(*DescribeConfigurationRevisionInput) 974 _ = input 975 if !ok { 976 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 977 } 978 979 opPath, opQuery := httpbinding.SplitURI("/v1/configurations/{ConfigurationId}/revisions/{ConfigurationRevision}") 980 request.URL.Path = opPath 981 if len(request.URL.RawQuery) > 0 { 982 request.URL.RawQuery = "&" + opQuery 983 } else { 984 request.URL.RawQuery = opQuery 985 } 986 987 request.Method = "GET" 988 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 989 if err != nil { 990 return out, metadata, &smithy.SerializationError{Err: err} 991 } 992 993 if err := awsRestjson1_serializeOpHttpBindingsDescribeConfigurationRevisionInput(input, restEncoder); err != nil { 994 return out, metadata, &smithy.SerializationError{Err: err} 995 } 996 997 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 998 return out, metadata, &smithy.SerializationError{Err: err} 999 } 1000 in.Request = request 1001 1002 return next.HandleSerialize(ctx, in) 1003} 1004func awsRestjson1_serializeOpHttpBindingsDescribeConfigurationRevisionInput(v *DescribeConfigurationRevisionInput, encoder *httpbinding.Encoder) error { 1005 if v == nil { 1006 return fmt.Errorf("unsupported serialization of nil %T", v) 1007 } 1008 1009 if v.ConfigurationId == nil || len(*v.ConfigurationId) == 0 { 1010 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationId must not be empty")} 1011 } 1012 if v.ConfigurationId != nil { 1013 if err := encoder.SetURI("ConfigurationId").String(*v.ConfigurationId); err != nil { 1014 return err 1015 } 1016 } 1017 1018 if v.ConfigurationRevision == nil || len(*v.ConfigurationRevision) == 0 { 1019 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationRevision must not be empty")} 1020 } 1021 if v.ConfigurationRevision != nil { 1022 if err := encoder.SetURI("ConfigurationRevision").String(*v.ConfigurationRevision); err != nil { 1023 return err 1024 } 1025 } 1026 1027 return nil 1028} 1029 1030type awsRestjson1_serializeOpDescribeUser struct { 1031} 1032 1033func (*awsRestjson1_serializeOpDescribeUser) ID() string { 1034 return "OperationSerializer" 1035} 1036 1037func (m *awsRestjson1_serializeOpDescribeUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1038 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1039) { 1040 request, ok := in.Request.(*smithyhttp.Request) 1041 if !ok { 1042 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1043 } 1044 1045 input, ok := in.Parameters.(*DescribeUserInput) 1046 _ = input 1047 if !ok { 1048 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1049 } 1050 1051 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}/users/{Username}") 1052 request.URL.Path = opPath 1053 if len(request.URL.RawQuery) > 0 { 1054 request.URL.RawQuery = "&" + opQuery 1055 } else { 1056 request.URL.RawQuery = opQuery 1057 } 1058 1059 request.Method = "GET" 1060 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1061 if err != nil { 1062 return out, metadata, &smithy.SerializationError{Err: err} 1063 } 1064 1065 if err := awsRestjson1_serializeOpHttpBindingsDescribeUserInput(input, restEncoder); err != nil { 1066 return out, metadata, &smithy.SerializationError{Err: err} 1067 } 1068 1069 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1070 return out, metadata, &smithy.SerializationError{Err: err} 1071 } 1072 in.Request = request 1073 1074 return next.HandleSerialize(ctx, in) 1075} 1076func awsRestjson1_serializeOpHttpBindingsDescribeUserInput(v *DescribeUserInput, encoder *httpbinding.Encoder) error { 1077 if v == nil { 1078 return fmt.Errorf("unsupported serialization of nil %T", v) 1079 } 1080 1081 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 1082 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 1083 } 1084 if v.BrokerId != nil { 1085 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 1086 return err 1087 } 1088 } 1089 1090 if v.Username == nil || len(*v.Username) == 0 { 1091 return &smithy.SerializationError{Err: fmt.Errorf("input member Username must not be empty")} 1092 } 1093 if v.Username != nil { 1094 if err := encoder.SetURI("Username").String(*v.Username); err != nil { 1095 return err 1096 } 1097 } 1098 1099 return nil 1100} 1101 1102type awsRestjson1_serializeOpListBrokers struct { 1103} 1104 1105func (*awsRestjson1_serializeOpListBrokers) ID() string { 1106 return "OperationSerializer" 1107} 1108 1109func (m *awsRestjson1_serializeOpListBrokers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1110 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1111) { 1112 request, ok := in.Request.(*smithyhttp.Request) 1113 if !ok { 1114 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1115 } 1116 1117 input, ok := in.Parameters.(*ListBrokersInput) 1118 _ = input 1119 if !ok { 1120 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1121 } 1122 1123 opPath, opQuery := httpbinding.SplitURI("/v1/brokers") 1124 request.URL.Path = opPath 1125 if len(request.URL.RawQuery) > 0 { 1126 request.URL.RawQuery = "&" + opQuery 1127 } else { 1128 request.URL.RawQuery = opQuery 1129 } 1130 1131 request.Method = "GET" 1132 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1133 if err != nil { 1134 return out, metadata, &smithy.SerializationError{Err: err} 1135 } 1136 1137 if err := awsRestjson1_serializeOpHttpBindingsListBrokersInput(input, restEncoder); err != nil { 1138 return out, metadata, &smithy.SerializationError{Err: err} 1139 } 1140 1141 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1142 return out, metadata, &smithy.SerializationError{Err: err} 1143 } 1144 in.Request = request 1145 1146 return next.HandleSerialize(ctx, in) 1147} 1148func awsRestjson1_serializeOpHttpBindingsListBrokersInput(v *ListBrokersInput, encoder *httpbinding.Encoder) error { 1149 if v == nil { 1150 return fmt.Errorf("unsupported serialization of nil %T", v) 1151 } 1152 1153 if v.MaxResults != 0 { 1154 encoder.SetQuery("maxResults").Integer(v.MaxResults) 1155 } 1156 1157 if v.NextToken != nil { 1158 encoder.SetQuery("nextToken").String(*v.NextToken) 1159 } 1160 1161 return nil 1162} 1163 1164type awsRestjson1_serializeOpListConfigurationRevisions struct { 1165} 1166 1167func (*awsRestjson1_serializeOpListConfigurationRevisions) ID() string { 1168 return "OperationSerializer" 1169} 1170 1171func (m *awsRestjson1_serializeOpListConfigurationRevisions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1172 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1173) { 1174 request, ok := in.Request.(*smithyhttp.Request) 1175 if !ok { 1176 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1177 } 1178 1179 input, ok := in.Parameters.(*ListConfigurationRevisionsInput) 1180 _ = input 1181 if !ok { 1182 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1183 } 1184 1185 opPath, opQuery := httpbinding.SplitURI("/v1/configurations/{ConfigurationId}/revisions") 1186 request.URL.Path = opPath 1187 if len(request.URL.RawQuery) > 0 { 1188 request.URL.RawQuery = "&" + opQuery 1189 } else { 1190 request.URL.RawQuery = opQuery 1191 } 1192 1193 request.Method = "GET" 1194 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1195 if err != nil { 1196 return out, metadata, &smithy.SerializationError{Err: err} 1197 } 1198 1199 if err := awsRestjson1_serializeOpHttpBindingsListConfigurationRevisionsInput(input, restEncoder); err != nil { 1200 return out, metadata, &smithy.SerializationError{Err: err} 1201 } 1202 1203 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1204 return out, metadata, &smithy.SerializationError{Err: err} 1205 } 1206 in.Request = request 1207 1208 return next.HandleSerialize(ctx, in) 1209} 1210func awsRestjson1_serializeOpHttpBindingsListConfigurationRevisionsInput(v *ListConfigurationRevisionsInput, encoder *httpbinding.Encoder) error { 1211 if v == nil { 1212 return fmt.Errorf("unsupported serialization of nil %T", v) 1213 } 1214 1215 if v.ConfigurationId == nil || len(*v.ConfigurationId) == 0 { 1216 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationId must not be empty")} 1217 } 1218 if v.ConfigurationId != nil { 1219 if err := encoder.SetURI("ConfigurationId").String(*v.ConfigurationId); err != nil { 1220 return err 1221 } 1222 } 1223 1224 if v.MaxResults != 0 { 1225 encoder.SetQuery("maxResults").Integer(v.MaxResults) 1226 } 1227 1228 if v.NextToken != nil { 1229 encoder.SetQuery("nextToken").String(*v.NextToken) 1230 } 1231 1232 return nil 1233} 1234 1235type awsRestjson1_serializeOpListConfigurations struct { 1236} 1237 1238func (*awsRestjson1_serializeOpListConfigurations) ID() string { 1239 return "OperationSerializer" 1240} 1241 1242func (m *awsRestjson1_serializeOpListConfigurations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1243 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1244) { 1245 request, ok := in.Request.(*smithyhttp.Request) 1246 if !ok { 1247 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1248 } 1249 1250 input, ok := in.Parameters.(*ListConfigurationsInput) 1251 _ = input 1252 if !ok { 1253 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1254 } 1255 1256 opPath, opQuery := httpbinding.SplitURI("/v1/configurations") 1257 request.URL.Path = opPath 1258 if len(request.URL.RawQuery) > 0 { 1259 request.URL.RawQuery = "&" + opQuery 1260 } else { 1261 request.URL.RawQuery = opQuery 1262 } 1263 1264 request.Method = "GET" 1265 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1266 if err != nil { 1267 return out, metadata, &smithy.SerializationError{Err: err} 1268 } 1269 1270 if err := awsRestjson1_serializeOpHttpBindingsListConfigurationsInput(input, restEncoder); err != nil { 1271 return out, metadata, &smithy.SerializationError{Err: err} 1272 } 1273 1274 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1275 return out, metadata, &smithy.SerializationError{Err: err} 1276 } 1277 in.Request = request 1278 1279 return next.HandleSerialize(ctx, in) 1280} 1281func awsRestjson1_serializeOpHttpBindingsListConfigurationsInput(v *ListConfigurationsInput, encoder *httpbinding.Encoder) error { 1282 if v == nil { 1283 return fmt.Errorf("unsupported serialization of nil %T", v) 1284 } 1285 1286 if v.MaxResults != 0 { 1287 encoder.SetQuery("maxResults").Integer(v.MaxResults) 1288 } 1289 1290 if v.NextToken != nil { 1291 encoder.SetQuery("nextToken").String(*v.NextToken) 1292 } 1293 1294 return nil 1295} 1296 1297type awsRestjson1_serializeOpListTags struct { 1298} 1299 1300func (*awsRestjson1_serializeOpListTags) ID() string { 1301 return "OperationSerializer" 1302} 1303 1304func (m *awsRestjson1_serializeOpListTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1305 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1306) { 1307 request, ok := in.Request.(*smithyhttp.Request) 1308 if !ok { 1309 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1310 } 1311 1312 input, ok := in.Parameters.(*ListTagsInput) 1313 _ = input 1314 if !ok { 1315 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1316 } 1317 1318 opPath, opQuery := httpbinding.SplitURI("/v1/tags/{ResourceArn}") 1319 request.URL.Path = opPath 1320 if len(request.URL.RawQuery) > 0 { 1321 request.URL.RawQuery = "&" + opQuery 1322 } else { 1323 request.URL.RawQuery = opQuery 1324 } 1325 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_serializeOpHttpBindingsListTagsInput(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_serializeOpHttpBindingsListTagsInput(v *ListTagsInput, encoder *httpbinding.Encoder) error { 1344 if v == nil { 1345 return fmt.Errorf("unsupported serialization of nil %T", v) 1346 } 1347 1348 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1349 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1350 } 1351 if v.ResourceArn != nil { 1352 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1353 return err 1354 } 1355 } 1356 1357 return nil 1358} 1359 1360type awsRestjson1_serializeOpListUsers struct { 1361} 1362 1363func (*awsRestjson1_serializeOpListUsers) ID() string { 1364 return "OperationSerializer" 1365} 1366 1367func (m *awsRestjson1_serializeOpListUsers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1368 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1369) { 1370 request, ok := in.Request.(*smithyhttp.Request) 1371 if !ok { 1372 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1373 } 1374 1375 input, ok := in.Parameters.(*ListUsersInput) 1376 _ = input 1377 if !ok { 1378 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1379 } 1380 1381 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}/users") 1382 request.URL.Path = opPath 1383 if len(request.URL.RawQuery) > 0 { 1384 request.URL.RawQuery = "&" + opQuery 1385 } else { 1386 request.URL.RawQuery = opQuery 1387 } 1388 1389 request.Method = "GET" 1390 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1391 if err != nil { 1392 return out, metadata, &smithy.SerializationError{Err: err} 1393 } 1394 1395 if err := awsRestjson1_serializeOpHttpBindingsListUsersInput(input, restEncoder); err != nil { 1396 return out, metadata, &smithy.SerializationError{Err: err} 1397 } 1398 1399 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1400 return out, metadata, &smithy.SerializationError{Err: err} 1401 } 1402 in.Request = request 1403 1404 return next.HandleSerialize(ctx, in) 1405} 1406func awsRestjson1_serializeOpHttpBindingsListUsersInput(v *ListUsersInput, encoder *httpbinding.Encoder) error { 1407 if v == nil { 1408 return fmt.Errorf("unsupported serialization of nil %T", v) 1409 } 1410 1411 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 1412 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 1413 } 1414 if v.BrokerId != nil { 1415 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 1416 return err 1417 } 1418 } 1419 1420 if v.MaxResults != 0 { 1421 encoder.SetQuery("maxResults").Integer(v.MaxResults) 1422 } 1423 1424 if v.NextToken != nil { 1425 encoder.SetQuery("nextToken").String(*v.NextToken) 1426 } 1427 1428 return nil 1429} 1430 1431type awsRestjson1_serializeOpRebootBroker struct { 1432} 1433 1434func (*awsRestjson1_serializeOpRebootBroker) ID() string { 1435 return "OperationSerializer" 1436} 1437 1438func (m *awsRestjson1_serializeOpRebootBroker) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1439 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1440) { 1441 request, ok := in.Request.(*smithyhttp.Request) 1442 if !ok { 1443 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1444 } 1445 1446 input, ok := in.Parameters.(*RebootBrokerInput) 1447 _ = input 1448 if !ok { 1449 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1450 } 1451 1452 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}/reboot") 1453 request.URL.Path = opPath 1454 if len(request.URL.RawQuery) > 0 { 1455 request.URL.RawQuery = "&" + opQuery 1456 } else { 1457 request.URL.RawQuery = opQuery 1458 } 1459 1460 request.Method = "POST" 1461 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1462 if err != nil { 1463 return out, metadata, &smithy.SerializationError{Err: err} 1464 } 1465 1466 if err := awsRestjson1_serializeOpHttpBindingsRebootBrokerInput(input, restEncoder); err != nil { 1467 return out, metadata, &smithy.SerializationError{Err: err} 1468 } 1469 1470 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1471 return out, metadata, &smithy.SerializationError{Err: err} 1472 } 1473 in.Request = request 1474 1475 return next.HandleSerialize(ctx, in) 1476} 1477func awsRestjson1_serializeOpHttpBindingsRebootBrokerInput(v *RebootBrokerInput, encoder *httpbinding.Encoder) error { 1478 if v == nil { 1479 return fmt.Errorf("unsupported serialization of nil %T", v) 1480 } 1481 1482 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 1483 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 1484 } 1485 if v.BrokerId != nil { 1486 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 1487 return err 1488 } 1489 } 1490 1491 return nil 1492} 1493 1494type awsRestjson1_serializeOpUpdateBroker struct { 1495} 1496 1497func (*awsRestjson1_serializeOpUpdateBroker) ID() string { 1498 return "OperationSerializer" 1499} 1500 1501func (m *awsRestjson1_serializeOpUpdateBroker) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1502 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1503) { 1504 request, ok := in.Request.(*smithyhttp.Request) 1505 if !ok { 1506 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1507 } 1508 1509 input, ok := in.Parameters.(*UpdateBrokerInput) 1510 _ = input 1511 if !ok { 1512 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1513 } 1514 1515 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}") 1516 request.URL.Path = opPath 1517 if len(request.URL.RawQuery) > 0 { 1518 request.URL.RawQuery = "&" + opQuery 1519 } else { 1520 request.URL.RawQuery = opQuery 1521 } 1522 1523 request.Method = "PUT" 1524 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1525 if err != nil { 1526 return out, metadata, &smithy.SerializationError{Err: err} 1527 } 1528 1529 if err := awsRestjson1_serializeOpHttpBindingsUpdateBrokerInput(input, restEncoder); err != nil { 1530 return out, metadata, &smithy.SerializationError{Err: err} 1531 } 1532 1533 restEncoder.SetHeader("Content-Type").String("application/json") 1534 1535 jsonEncoder := smithyjson.NewEncoder() 1536 if err := awsRestjson1_serializeOpDocumentUpdateBrokerInput(input, jsonEncoder.Value); err != nil { 1537 return out, metadata, &smithy.SerializationError{Err: err} 1538 } 1539 1540 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1541 return out, metadata, &smithy.SerializationError{Err: err} 1542 } 1543 1544 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1545 return out, metadata, &smithy.SerializationError{Err: err} 1546 } 1547 in.Request = request 1548 1549 return next.HandleSerialize(ctx, in) 1550} 1551func awsRestjson1_serializeOpHttpBindingsUpdateBrokerInput(v *UpdateBrokerInput, encoder *httpbinding.Encoder) error { 1552 if v == nil { 1553 return fmt.Errorf("unsupported serialization of nil %T", v) 1554 } 1555 1556 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 1557 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 1558 } 1559 if v.BrokerId != nil { 1560 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 1561 return err 1562 } 1563 } 1564 1565 return nil 1566} 1567 1568func awsRestjson1_serializeOpDocumentUpdateBrokerInput(v *UpdateBrokerInput, value smithyjson.Value) error { 1569 object := value.Object() 1570 defer object.Close() 1571 1572 if len(v.AuthenticationStrategy) > 0 { 1573 ok := object.Key("authenticationStrategy") 1574 ok.String(string(v.AuthenticationStrategy)) 1575 } 1576 1577 if v.AutoMinorVersionUpgrade { 1578 ok := object.Key("autoMinorVersionUpgrade") 1579 ok.Boolean(v.AutoMinorVersionUpgrade) 1580 } 1581 1582 if v.Configuration != nil { 1583 ok := object.Key("configuration") 1584 if err := awsRestjson1_serializeDocumentConfigurationId(v.Configuration, ok); err != nil { 1585 return err 1586 } 1587 } 1588 1589 if v.EngineVersion != nil { 1590 ok := object.Key("engineVersion") 1591 ok.String(*v.EngineVersion) 1592 } 1593 1594 if v.HostInstanceType != nil { 1595 ok := object.Key("hostInstanceType") 1596 ok.String(*v.HostInstanceType) 1597 } 1598 1599 if v.LdapServerMetadata != nil { 1600 ok := object.Key("ldapServerMetadata") 1601 if err := awsRestjson1_serializeDocumentLdapServerMetadataInput(v.LdapServerMetadata, ok); err != nil { 1602 return err 1603 } 1604 } 1605 1606 if v.Logs != nil { 1607 ok := object.Key("logs") 1608 if err := awsRestjson1_serializeDocumentLogs(v.Logs, ok); err != nil { 1609 return err 1610 } 1611 } 1612 1613 if v.SecurityGroups != nil { 1614 ok := object.Key("securityGroups") 1615 if err := awsRestjson1_serializeDocument__listOf__string(v.SecurityGroups, ok); err != nil { 1616 return err 1617 } 1618 } 1619 1620 return nil 1621} 1622 1623type awsRestjson1_serializeOpUpdateConfiguration struct { 1624} 1625 1626func (*awsRestjson1_serializeOpUpdateConfiguration) ID() string { 1627 return "OperationSerializer" 1628} 1629 1630func (m *awsRestjson1_serializeOpUpdateConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1631 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1632) { 1633 request, ok := in.Request.(*smithyhttp.Request) 1634 if !ok { 1635 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1636 } 1637 1638 input, ok := in.Parameters.(*UpdateConfigurationInput) 1639 _ = input 1640 if !ok { 1641 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1642 } 1643 1644 opPath, opQuery := httpbinding.SplitURI("/v1/configurations/{ConfigurationId}") 1645 request.URL.Path = opPath 1646 if len(request.URL.RawQuery) > 0 { 1647 request.URL.RawQuery = "&" + opQuery 1648 } else { 1649 request.URL.RawQuery = opQuery 1650 } 1651 1652 request.Method = "PUT" 1653 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1654 if err != nil { 1655 return out, metadata, &smithy.SerializationError{Err: err} 1656 } 1657 1658 if err := awsRestjson1_serializeOpHttpBindingsUpdateConfigurationInput(input, restEncoder); err != nil { 1659 return out, metadata, &smithy.SerializationError{Err: err} 1660 } 1661 1662 restEncoder.SetHeader("Content-Type").String("application/json") 1663 1664 jsonEncoder := smithyjson.NewEncoder() 1665 if err := awsRestjson1_serializeOpDocumentUpdateConfigurationInput(input, jsonEncoder.Value); err != nil { 1666 return out, metadata, &smithy.SerializationError{Err: err} 1667 } 1668 1669 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1670 return out, metadata, &smithy.SerializationError{Err: err} 1671 } 1672 1673 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1674 return out, metadata, &smithy.SerializationError{Err: err} 1675 } 1676 in.Request = request 1677 1678 return next.HandleSerialize(ctx, in) 1679} 1680func awsRestjson1_serializeOpHttpBindingsUpdateConfigurationInput(v *UpdateConfigurationInput, encoder *httpbinding.Encoder) error { 1681 if v == nil { 1682 return fmt.Errorf("unsupported serialization of nil %T", v) 1683 } 1684 1685 if v.ConfigurationId == nil || len(*v.ConfigurationId) == 0 { 1686 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationId must not be empty")} 1687 } 1688 if v.ConfigurationId != nil { 1689 if err := encoder.SetURI("ConfigurationId").String(*v.ConfigurationId); err != nil { 1690 return err 1691 } 1692 } 1693 1694 return nil 1695} 1696 1697func awsRestjson1_serializeOpDocumentUpdateConfigurationInput(v *UpdateConfigurationInput, value smithyjson.Value) error { 1698 object := value.Object() 1699 defer object.Close() 1700 1701 if v.Data != nil { 1702 ok := object.Key("data") 1703 ok.String(*v.Data) 1704 } 1705 1706 if v.Description != nil { 1707 ok := object.Key("description") 1708 ok.String(*v.Description) 1709 } 1710 1711 return nil 1712} 1713 1714type awsRestjson1_serializeOpUpdateUser struct { 1715} 1716 1717func (*awsRestjson1_serializeOpUpdateUser) ID() string { 1718 return "OperationSerializer" 1719} 1720 1721func (m *awsRestjson1_serializeOpUpdateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1722 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1723) { 1724 request, ok := in.Request.(*smithyhttp.Request) 1725 if !ok { 1726 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1727 } 1728 1729 input, ok := in.Parameters.(*UpdateUserInput) 1730 _ = input 1731 if !ok { 1732 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1733 } 1734 1735 opPath, opQuery := httpbinding.SplitURI("/v1/brokers/{BrokerId}/users/{Username}") 1736 request.URL.Path = opPath 1737 if len(request.URL.RawQuery) > 0 { 1738 request.URL.RawQuery = "&" + opQuery 1739 } else { 1740 request.URL.RawQuery = opQuery 1741 } 1742 1743 request.Method = "PUT" 1744 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1745 if err != nil { 1746 return out, metadata, &smithy.SerializationError{Err: err} 1747 } 1748 1749 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserInput(input, restEncoder); err != nil { 1750 return out, metadata, &smithy.SerializationError{Err: err} 1751 } 1752 1753 restEncoder.SetHeader("Content-Type").String("application/json") 1754 1755 jsonEncoder := smithyjson.NewEncoder() 1756 if err := awsRestjson1_serializeOpDocumentUpdateUserInput(input, jsonEncoder.Value); err != nil { 1757 return out, metadata, &smithy.SerializationError{Err: err} 1758 } 1759 1760 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1761 return out, metadata, &smithy.SerializationError{Err: err} 1762 } 1763 1764 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1765 return out, metadata, &smithy.SerializationError{Err: err} 1766 } 1767 in.Request = request 1768 1769 return next.HandleSerialize(ctx, in) 1770} 1771func awsRestjson1_serializeOpHttpBindingsUpdateUserInput(v *UpdateUserInput, encoder *httpbinding.Encoder) error { 1772 if v == nil { 1773 return fmt.Errorf("unsupported serialization of nil %T", v) 1774 } 1775 1776 if v.BrokerId == nil || len(*v.BrokerId) == 0 { 1777 return &smithy.SerializationError{Err: fmt.Errorf("input member BrokerId must not be empty")} 1778 } 1779 if v.BrokerId != nil { 1780 if err := encoder.SetURI("BrokerId").String(*v.BrokerId); err != nil { 1781 return err 1782 } 1783 } 1784 1785 if v.Username == nil || len(*v.Username) == 0 { 1786 return &smithy.SerializationError{Err: fmt.Errorf("input member Username must not be empty")} 1787 } 1788 if v.Username != nil { 1789 if err := encoder.SetURI("Username").String(*v.Username); err != nil { 1790 return err 1791 } 1792 } 1793 1794 return nil 1795} 1796 1797func awsRestjson1_serializeOpDocumentUpdateUserInput(v *UpdateUserInput, value smithyjson.Value) error { 1798 object := value.Object() 1799 defer object.Close() 1800 1801 if v.ConsoleAccess { 1802 ok := object.Key("consoleAccess") 1803 ok.Boolean(v.ConsoleAccess) 1804 } 1805 1806 if v.Groups != nil { 1807 ok := object.Key("groups") 1808 if err := awsRestjson1_serializeDocument__listOf__string(v.Groups, ok); err != nil { 1809 return err 1810 } 1811 } 1812 1813 if v.Password != nil { 1814 ok := object.Key("password") 1815 ok.String(*v.Password) 1816 } 1817 1818 return nil 1819} 1820 1821func awsRestjson1_serializeDocument__listOf__string(v []string, value smithyjson.Value) error { 1822 array := value.Array() 1823 defer array.Close() 1824 1825 for i := range v { 1826 av := array.Value() 1827 av.String(v[i]) 1828 } 1829 return nil 1830} 1831 1832func awsRestjson1_serializeDocument__listOfUser(v []types.User, value smithyjson.Value) error { 1833 array := value.Array() 1834 defer array.Close() 1835 1836 for i := range v { 1837 av := array.Value() 1838 if err := awsRestjson1_serializeDocumentUser(&v[i], av); err != nil { 1839 return err 1840 } 1841 } 1842 return nil 1843} 1844 1845func awsRestjson1_serializeDocument__mapOf__string(v map[string]string, value smithyjson.Value) error { 1846 object := value.Object() 1847 defer object.Close() 1848 1849 for key := range v { 1850 om := object.Key(key) 1851 om.String(v[key]) 1852 } 1853 return nil 1854} 1855 1856func awsRestjson1_serializeDocumentConfigurationId(v *types.ConfigurationId, value smithyjson.Value) error { 1857 object := value.Object() 1858 defer object.Close() 1859 1860 if v.Id != nil { 1861 ok := object.Key("id") 1862 ok.String(*v.Id) 1863 } 1864 1865 if v.Revision != 0 { 1866 ok := object.Key("revision") 1867 ok.Integer(v.Revision) 1868 } 1869 1870 return nil 1871} 1872 1873func awsRestjson1_serializeDocumentEncryptionOptions(v *types.EncryptionOptions, value smithyjson.Value) error { 1874 object := value.Object() 1875 defer object.Close() 1876 1877 if v.KmsKeyId != nil { 1878 ok := object.Key("kmsKeyId") 1879 ok.String(*v.KmsKeyId) 1880 } 1881 1882 if v.UseAwsOwnedKey { 1883 ok := object.Key("useAwsOwnedKey") 1884 ok.Boolean(v.UseAwsOwnedKey) 1885 } 1886 1887 return nil 1888} 1889 1890func awsRestjson1_serializeDocumentLdapServerMetadataInput(v *types.LdapServerMetadataInput, value smithyjson.Value) error { 1891 object := value.Object() 1892 defer object.Close() 1893 1894 if v.Hosts != nil { 1895 ok := object.Key("hosts") 1896 if err := awsRestjson1_serializeDocument__listOf__string(v.Hosts, ok); err != nil { 1897 return err 1898 } 1899 } 1900 1901 if v.RoleBase != nil { 1902 ok := object.Key("roleBase") 1903 ok.String(*v.RoleBase) 1904 } 1905 1906 if v.RoleName != nil { 1907 ok := object.Key("roleName") 1908 ok.String(*v.RoleName) 1909 } 1910 1911 if v.RoleSearchMatching != nil { 1912 ok := object.Key("roleSearchMatching") 1913 ok.String(*v.RoleSearchMatching) 1914 } 1915 1916 if v.RoleSearchSubtree { 1917 ok := object.Key("roleSearchSubtree") 1918 ok.Boolean(v.RoleSearchSubtree) 1919 } 1920 1921 if v.ServiceAccountPassword != nil { 1922 ok := object.Key("serviceAccountPassword") 1923 ok.String(*v.ServiceAccountPassword) 1924 } 1925 1926 if v.ServiceAccountUsername != nil { 1927 ok := object.Key("serviceAccountUsername") 1928 ok.String(*v.ServiceAccountUsername) 1929 } 1930 1931 if v.UserBase != nil { 1932 ok := object.Key("userBase") 1933 ok.String(*v.UserBase) 1934 } 1935 1936 if v.UserRoleName != nil { 1937 ok := object.Key("userRoleName") 1938 ok.String(*v.UserRoleName) 1939 } 1940 1941 if v.UserSearchMatching != nil { 1942 ok := object.Key("userSearchMatching") 1943 ok.String(*v.UserSearchMatching) 1944 } 1945 1946 if v.UserSearchSubtree { 1947 ok := object.Key("userSearchSubtree") 1948 ok.Boolean(v.UserSearchSubtree) 1949 } 1950 1951 return nil 1952} 1953 1954func awsRestjson1_serializeDocumentLogs(v *types.Logs, value smithyjson.Value) error { 1955 object := value.Object() 1956 defer object.Close() 1957 1958 if v.Audit { 1959 ok := object.Key("audit") 1960 ok.Boolean(v.Audit) 1961 } 1962 1963 if v.General { 1964 ok := object.Key("general") 1965 ok.Boolean(v.General) 1966 } 1967 1968 return nil 1969} 1970 1971func awsRestjson1_serializeDocumentUser(v *types.User, value smithyjson.Value) error { 1972 object := value.Object() 1973 defer object.Close() 1974 1975 if v.ConsoleAccess { 1976 ok := object.Key("consoleAccess") 1977 ok.Boolean(v.ConsoleAccess) 1978 } 1979 1980 if v.Groups != nil { 1981 ok := object.Key("groups") 1982 if err := awsRestjson1_serializeDocument__listOf__string(v.Groups, ok); err != nil { 1983 return err 1984 } 1985 } 1986 1987 if v.Password != nil { 1988 ok := object.Key("password") 1989 ok.String(*v.Password) 1990 } 1991 1992 if v.Username != nil { 1993 ok := object.Key("username") 1994 ok.String(*v.Username) 1995 } 1996 1997 return nil 1998} 1999 2000func awsRestjson1_serializeDocumentWeeklyStartTime(v *types.WeeklyStartTime, value smithyjson.Value) error { 2001 object := value.Object() 2002 defer object.Close() 2003 2004 if len(v.DayOfWeek) > 0 { 2005 ok := object.Key("dayOfWeek") 2006 ok.String(string(v.DayOfWeek)) 2007 } 2008 2009 if v.TimeOfDay != nil { 2010 ok := object.Key("timeOfDay") 2011 ok.String(*v.TimeOfDay) 2012 } 2013 2014 if v.TimeZone != nil { 2015 ok := object.Key("timeZone") 2016 ok.String(*v.TimeZone) 2017 } 2018 2019 return nil 2020} 2021