1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package macie2 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/macie2/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_serializeOpAcceptInvitation struct { 18} 19 20func (*awsRestjson1_serializeOpAcceptInvitation) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpAcceptInvitation) 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.(*AcceptInvitationInput) 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("/invitations/accept") 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 restEncoder.SetHeader("Content-Type").String("application/json") 48 49 jsonEncoder := smithyjson.NewEncoder() 50 if err := awsRestjson1_serializeOpDocumentAcceptInvitationInput(input, jsonEncoder.Value); err != nil { 51 return out, metadata, &smithy.SerializationError{Err: err} 52 } 53 54 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 55 return out, metadata, &smithy.SerializationError{Err: err} 56 } 57 58 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 59 return out, metadata, &smithy.SerializationError{Err: err} 60 } 61 in.Request = request 62 63 return next.HandleSerialize(ctx, in) 64} 65func awsRestjson1_serializeOpHttpBindingsAcceptInvitationInput(v *AcceptInvitationInput, encoder *httpbinding.Encoder) error { 66 if v == nil { 67 return fmt.Errorf("unsupported serialization of nil %T", v) 68 } 69 70 return nil 71} 72 73func awsRestjson1_serializeOpDocumentAcceptInvitationInput(v *AcceptInvitationInput, value smithyjson.Value) error { 74 object := value.Object() 75 defer object.Close() 76 77 if v.AdministratorAccountId != nil { 78 ok := object.Key("administratorAccountId") 79 ok.String(*v.AdministratorAccountId) 80 } 81 82 if v.InvitationId != nil { 83 ok := object.Key("invitationId") 84 ok.String(*v.InvitationId) 85 } 86 87 if v.MasterAccount != nil { 88 ok := object.Key("masterAccount") 89 ok.String(*v.MasterAccount) 90 } 91 92 return nil 93} 94 95type awsRestjson1_serializeOpBatchGetCustomDataIdentifiers struct { 96} 97 98func (*awsRestjson1_serializeOpBatchGetCustomDataIdentifiers) ID() string { 99 return "OperationSerializer" 100} 101 102func (m *awsRestjson1_serializeOpBatchGetCustomDataIdentifiers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 103 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 104) { 105 request, ok := in.Request.(*smithyhttp.Request) 106 if !ok { 107 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 108 } 109 110 input, ok := in.Parameters.(*BatchGetCustomDataIdentifiersInput) 111 _ = input 112 if !ok { 113 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 114 } 115 116 opPath, opQuery := httpbinding.SplitURI("/custom-data-identifiers/get") 117 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 118 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 119 request.Method = "POST" 120 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 121 if err != nil { 122 return out, metadata, &smithy.SerializationError{Err: err} 123 } 124 125 restEncoder.SetHeader("Content-Type").String("application/json") 126 127 jsonEncoder := smithyjson.NewEncoder() 128 if err := awsRestjson1_serializeOpDocumentBatchGetCustomDataIdentifiersInput(input, jsonEncoder.Value); err != nil { 129 return out, metadata, &smithy.SerializationError{Err: err} 130 } 131 132 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 133 return out, metadata, &smithy.SerializationError{Err: err} 134 } 135 136 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 137 return out, metadata, &smithy.SerializationError{Err: err} 138 } 139 in.Request = request 140 141 return next.HandleSerialize(ctx, in) 142} 143func awsRestjson1_serializeOpHttpBindingsBatchGetCustomDataIdentifiersInput(v *BatchGetCustomDataIdentifiersInput, encoder *httpbinding.Encoder) error { 144 if v == nil { 145 return fmt.Errorf("unsupported serialization of nil %T", v) 146 } 147 148 return nil 149} 150 151func awsRestjson1_serializeOpDocumentBatchGetCustomDataIdentifiersInput(v *BatchGetCustomDataIdentifiersInput, value smithyjson.Value) error { 152 object := value.Object() 153 defer object.Close() 154 155 if v.Ids != nil { 156 ok := object.Key("ids") 157 if err := awsRestjson1_serializeDocument__listOf__string(v.Ids, ok); err != nil { 158 return err 159 } 160 } 161 162 return nil 163} 164 165type awsRestjson1_serializeOpCreateClassificationJob struct { 166} 167 168func (*awsRestjson1_serializeOpCreateClassificationJob) ID() string { 169 return "OperationSerializer" 170} 171 172func (m *awsRestjson1_serializeOpCreateClassificationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 173 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 174) { 175 request, ok := in.Request.(*smithyhttp.Request) 176 if !ok { 177 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 178 } 179 180 input, ok := in.Parameters.(*CreateClassificationJobInput) 181 _ = input 182 if !ok { 183 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 184 } 185 186 opPath, opQuery := httpbinding.SplitURI("/jobs") 187 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 188 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 189 request.Method = "POST" 190 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 191 if err != nil { 192 return out, metadata, &smithy.SerializationError{Err: err} 193 } 194 195 restEncoder.SetHeader("Content-Type").String("application/json") 196 197 jsonEncoder := smithyjson.NewEncoder() 198 if err := awsRestjson1_serializeOpDocumentCreateClassificationJobInput(input, jsonEncoder.Value); err != nil { 199 return out, metadata, &smithy.SerializationError{Err: err} 200 } 201 202 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 203 return out, metadata, &smithy.SerializationError{Err: err} 204 } 205 206 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 207 return out, metadata, &smithy.SerializationError{Err: err} 208 } 209 in.Request = request 210 211 return next.HandleSerialize(ctx, in) 212} 213func awsRestjson1_serializeOpHttpBindingsCreateClassificationJobInput(v *CreateClassificationJobInput, encoder *httpbinding.Encoder) error { 214 if v == nil { 215 return fmt.Errorf("unsupported serialization of nil %T", v) 216 } 217 218 return nil 219} 220 221func awsRestjson1_serializeOpDocumentCreateClassificationJobInput(v *CreateClassificationJobInput, value smithyjson.Value) error { 222 object := value.Object() 223 defer object.Close() 224 225 if v.ClientToken != nil { 226 ok := object.Key("clientToken") 227 ok.String(*v.ClientToken) 228 } 229 230 if v.CustomDataIdentifierIds != nil { 231 ok := object.Key("customDataIdentifierIds") 232 if err := awsRestjson1_serializeDocument__listOf__string(v.CustomDataIdentifierIds, ok); err != nil { 233 return err 234 } 235 } 236 237 if v.Description != nil { 238 ok := object.Key("description") 239 ok.String(*v.Description) 240 } 241 242 if v.InitialRun { 243 ok := object.Key("initialRun") 244 ok.Boolean(v.InitialRun) 245 } 246 247 if len(v.JobType) > 0 { 248 ok := object.Key("jobType") 249 ok.String(string(v.JobType)) 250 } 251 252 if v.Name != nil { 253 ok := object.Key("name") 254 ok.String(*v.Name) 255 } 256 257 if v.S3JobDefinition != nil { 258 ok := object.Key("s3JobDefinition") 259 if err := awsRestjson1_serializeDocumentS3JobDefinition(v.S3JobDefinition, ok); err != nil { 260 return err 261 } 262 } 263 264 if v.SamplingPercentage != 0 { 265 ok := object.Key("samplingPercentage") 266 ok.Integer(v.SamplingPercentage) 267 } 268 269 if v.ScheduleFrequency != nil { 270 ok := object.Key("scheduleFrequency") 271 if err := awsRestjson1_serializeDocumentJobScheduleFrequency(v.ScheduleFrequency, ok); err != nil { 272 return err 273 } 274 } 275 276 if v.Tags != nil { 277 ok := object.Key("tags") 278 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 279 return err 280 } 281 } 282 283 return nil 284} 285 286type awsRestjson1_serializeOpCreateCustomDataIdentifier struct { 287} 288 289func (*awsRestjson1_serializeOpCreateCustomDataIdentifier) ID() string { 290 return "OperationSerializer" 291} 292 293func (m *awsRestjson1_serializeOpCreateCustomDataIdentifier) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 294 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 295) { 296 request, ok := in.Request.(*smithyhttp.Request) 297 if !ok { 298 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 299 } 300 301 input, ok := in.Parameters.(*CreateCustomDataIdentifierInput) 302 _ = input 303 if !ok { 304 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 305 } 306 307 opPath, opQuery := httpbinding.SplitURI("/custom-data-identifiers") 308 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 309 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 310 request.Method = "POST" 311 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 312 if err != nil { 313 return out, metadata, &smithy.SerializationError{Err: err} 314 } 315 316 restEncoder.SetHeader("Content-Type").String("application/json") 317 318 jsonEncoder := smithyjson.NewEncoder() 319 if err := awsRestjson1_serializeOpDocumentCreateCustomDataIdentifierInput(input, jsonEncoder.Value); err != nil { 320 return out, metadata, &smithy.SerializationError{Err: err} 321 } 322 323 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 324 return out, metadata, &smithy.SerializationError{Err: err} 325 } 326 327 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 328 return out, metadata, &smithy.SerializationError{Err: err} 329 } 330 in.Request = request 331 332 return next.HandleSerialize(ctx, in) 333} 334func awsRestjson1_serializeOpHttpBindingsCreateCustomDataIdentifierInput(v *CreateCustomDataIdentifierInput, encoder *httpbinding.Encoder) error { 335 if v == nil { 336 return fmt.Errorf("unsupported serialization of nil %T", v) 337 } 338 339 return nil 340} 341 342func awsRestjson1_serializeOpDocumentCreateCustomDataIdentifierInput(v *CreateCustomDataIdentifierInput, value smithyjson.Value) error { 343 object := value.Object() 344 defer object.Close() 345 346 if v.ClientToken != nil { 347 ok := object.Key("clientToken") 348 ok.String(*v.ClientToken) 349 } 350 351 if v.Description != nil { 352 ok := object.Key("description") 353 ok.String(*v.Description) 354 } 355 356 if v.IgnoreWords != nil { 357 ok := object.Key("ignoreWords") 358 if err := awsRestjson1_serializeDocument__listOf__string(v.IgnoreWords, ok); err != nil { 359 return err 360 } 361 } 362 363 if v.Keywords != nil { 364 ok := object.Key("keywords") 365 if err := awsRestjson1_serializeDocument__listOf__string(v.Keywords, ok); err != nil { 366 return err 367 } 368 } 369 370 if v.MaximumMatchDistance != 0 { 371 ok := object.Key("maximumMatchDistance") 372 ok.Integer(v.MaximumMatchDistance) 373 } 374 375 if v.Name != nil { 376 ok := object.Key("name") 377 ok.String(*v.Name) 378 } 379 380 if v.Regex != nil { 381 ok := object.Key("regex") 382 ok.String(*v.Regex) 383 } 384 385 if v.Tags != nil { 386 ok := object.Key("tags") 387 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 388 return err 389 } 390 } 391 392 return nil 393} 394 395type awsRestjson1_serializeOpCreateFindingsFilter struct { 396} 397 398func (*awsRestjson1_serializeOpCreateFindingsFilter) ID() string { 399 return "OperationSerializer" 400} 401 402func (m *awsRestjson1_serializeOpCreateFindingsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 403 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 404) { 405 request, ok := in.Request.(*smithyhttp.Request) 406 if !ok { 407 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 408 } 409 410 input, ok := in.Parameters.(*CreateFindingsFilterInput) 411 _ = input 412 if !ok { 413 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 414 } 415 416 opPath, opQuery := httpbinding.SplitURI("/findingsfilters") 417 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 418 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 419 request.Method = "POST" 420 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 421 if err != nil { 422 return out, metadata, &smithy.SerializationError{Err: err} 423 } 424 425 restEncoder.SetHeader("Content-Type").String("application/json") 426 427 jsonEncoder := smithyjson.NewEncoder() 428 if err := awsRestjson1_serializeOpDocumentCreateFindingsFilterInput(input, jsonEncoder.Value); err != nil { 429 return out, metadata, &smithy.SerializationError{Err: err} 430 } 431 432 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 433 return out, metadata, &smithy.SerializationError{Err: err} 434 } 435 436 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 437 return out, metadata, &smithy.SerializationError{Err: err} 438 } 439 in.Request = request 440 441 return next.HandleSerialize(ctx, in) 442} 443func awsRestjson1_serializeOpHttpBindingsCreateFindingsFilterInput(v *CreateFindingsFilterInput, encoder *httpbinding.Encoder) error { 444 if v == nil { 445 return fmt.Errorf("unsupported serialization of nil %T", v) 446 } 447 448 return nil 449} 450 451func awsRestjson1_serializeOpDocumentCreateFindingsFilterInput(v *CreateFindingsFilterInput, value smithyjson.Value) error { 452 object := value.Object() 453 defer object.Close() 454 455 if len(v.Action) > 0 { 456 ok := object.Key("action") 457 ok.String(string(v.Action)) 458 } 459 460 if v.ClientToken != nil { 461 ok := object.Key("clientToken") 462 ok.String(*v.ClientToken) 463 } 464 465 if v.Description != nil { 466 ok := object.Key("description") 467 ok.String(*v.Description) 468 } 469 470 if v.FindingCriteria != nil { 471 ok := object.Key("findingCriteria") 472 if err := awsRestjson1_serializeDocumentFindingCriteria(v.FindingCriteria, ok); err != nil { 473 return err 474 } 475 } 476 477 if v.Name != nil { 478 ok := object.Key("name") 479 ok.String(*v.Name) 480 } 481 482 if v.Position != 0 { 483 ok := object.Key("position") 484 ok.Integer(v.Position) 485 } 486 487 if v.Tags != nil { 488 ok := object.Key("tags") 489 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 490 return err 491 } 492 } 493 494 return nil 495} 496 497type awsRestjson1_serializeOpCreateInvitations struct { 498} 499 500func (*awsRestjson1_serializeOpCreateInvitations) ID() string { 501 return "OperationSerializer" 502} 503 504func (m *awsRestjson1_serializeOpCreateInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 505 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 506) { 507 request, ok := in.Request.(*smithyhttp.Request) 508 if !ok { 509 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 510 } 511 512 input, ok := in.Parameters.(*CreateInvitationsInput) 513 _ = input 514 if !ok { 515 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 516 } 517 518 opPath, opQuery := httpbinding.SplitURI("/invitations") 519 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 520 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 521 request.Method = "POST" 522 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 523 if err != nil { 524 return out, metadata, &smithy.SerializationError{Err: err} 525 } 526 527 restEncoder.SetHeader("Content-Type").String("application/json") 528 529 jsonEncoder := smithyjson.NewEncoder() 530 if err := awsRestjson1_serializeOpDocumentCreateInvitationsInput(input, jsonEncoder.Value); err != nil { 531 return out, metadata, &smithy.SerializationError{Err: err} 532 } 533 534 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 535 return out, metadata, &smithy.SerializationError{Err: err} 536 } 537 538 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 539 return out, metadata, &smithy.SerializationError{Err: err} 540 } 541 in.Request = request 542 543 return next.HandleSerialize(ctx, in) 544} 545func awsRestjson1_serializeOpHttpBindingsCreateInvitationsInput(v *CreateInvitationsInput, encoder *httpbinding.Encoder) error { 546 if v == nil { 547 return fmt.Errorf("unsupported serialization of nil %T", v) 548 } 549 550 return nil 551} 552 553func awsRestjson1_serializeOpDocumentCreateInvitationsInput(v *CreateInvitationsInput, value smithyjson.Value) error { 554 object := value.Object() 555 defer object.Close() 556 557 if v.AccountIds != nil { 558 ok := object.Key("accountIds") 559 if err := awsRestjson1_serializeDocument__listOf__string(v.AccountIds, ok); err != nil { 560 return err 561 } 562 } 563 564 if v.DisableEmailNotification { 565 ok := object.Key("disableEmailNotification") 566 ok.Boolean(v.DisableEmailNotification) 567 } 568 569 if v.Message != nil { 570 ok := object.Key("message") 571 ok.String(*v.Message) 572 } 573 574 return nil 575} 576 577type awsRestjson1_serializeOpCreateMember struct { 578} 579 580func (*awsRestjson1_serializeOpCreateMember) ID() string { 581 return "OperationSerializer" 582} 583 584func (m *awsRestjson1_serializeOpCreateMember) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 585 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 586) { 587 request, ok := in.Request.(*smithyhttp.Request) 588 if !ok { 589 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 590 } 591 592 input, ok := in.Parameters.(*CreateMemberInput) 593 _ = input 594 if !ok { 595 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 596 } 597 598 opPath, opQuery := httpbinding.SplitURI("/members") 599 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 600 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 601 request.Method = "POST" 602 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 603 if err != nil { 604 return out, metadata, &smithy.SerializationError{Err: err} 605 } 606 607 restEncoder.SetHeader("Content-Type").String("application/json") 608 609 jsonEncoder := smithyjson.NewEncoder() 610 if err := awsRestjson1_serializeOpDocumentCreateMemberInput(input, jsonEncoder.Value); err != nil { 611 return out, metadata, &smithy.SerializationError{Err: err} 612 } 613 614 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 615 return out, metadata, &smithy.SerializationError{Err: err} 616 } 617 618 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 619 return out, metadata, &smithy.SerializationError{Err: err} 620 } 621 in.Request = request 622 623 return next.HandleSerialize(ctx, in) 624} 625func awsRestjson1_serializeOpHttpBindingsCreateMemberInput(v *CreateMemberInput, encoder *httpbinding.Encoder) error { 626 if v == nil { 627 return fmt.Errorf("unsupported serialization of nil %T", v) 628 } 629 630 return nil 631} 632 633func awsRestjson1_serializeOpDocumentCreateMemberInput(v *CreateMemberInput, value smithyjson.Value) error { 634 object := value.Object() 635 defer object.Close() 636 637 if v.Account != nil { 638 ok := object.Key("account") 639 if err := awsRestjson1_serializeDocumentAccountDetail(v.Account, ok); err != nil { 640 return err 641 } 642 } 643 644 if v.Tags != nil { 645 ok := object.Key("tags") 646 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 647 return err 648 } 649 } 650 651 return nil 652} 653 654type awsRestjson1_serializeOpCreateSampleFindings struct { 655} 656 657func (*awsRestjson1_serializeOpCreateSampleFindings) ID() string { 658 return "OperationSerializer" 659} 660 661func (m *awsRestjson1_serializeOpCreateSampleFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 662 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 663) { 664 request, ok := in.Request.(*smithyhttp.Request) 665 if !ok { 666 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 667 } 668 669 input, ok := in.Parameters.(*CreateSampleFindingsInput) 670 _ = input 671 if !ok { 672 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 673 } 674 675 opPath, opQuery := httpbinding.SplitURI("/findings/sample") 676 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 677 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 678 request.Method = "POST" 679 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 680 if err != nil { 681 return out, metadata, &smithy.SerializationError{Err: err} 682 } 683 684 restEncoder.SetHeader("Content-Type").String("application/json") 685 686 jsonEncoder := smithyjson.NewEncoder() 687 if err := awsRestjson1_serializeOpDocumentCreateSampleFindingsInput(input, jsonEncoder.Value); err != nil { 688 return out, metadata, &smithy.SerializationError{Err: err} 689 } 690 691 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 692 return out, metadata, &smithy.SerializationError{Err: err} 693 } 694 695 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 696 return out, metadata, &smithy.SerializationError{Err: err} 697 } 698 in.Request = request 699 700 return next.HandleSerialize(ctx, in) 701} 702func awsRestjson1_serializeOpHttpBindingsCreateSampleFindingsInput(v *CreateSampleFindingsInput, encoder *httpbinding.Encoder) error { 703 if v == nil { 704 return fmt.Errorf("unsupported serialization of nil %T", v) 705 } 706 707 return nil 708} 709 710func awsRestjson1_serializeOpDocumentCreateSampleFindingsInput(v *CreateSampleFindingsInput, value smithyjson.Value) error { 711 object := value.Object() 712 defer object.Close() 713 714 if v.FindingTypes != nil { 715 ok := object.Key("findingTypes") 716 if err := awsRestjson1_serializeDocument__listOfFindingType(v.FindingTypes, ok); err != nil { 717 return err 718 } 719 } 720 721 return nil 722} 723 724type awsRestjson1_serializeOpDeclineInvitations struct { 725} 726 727func (*awsRestjson1_serializeOpDeclineInvitations) ID() string { 728 return "OperationSerializer" 729} 730 731func (m *awsRestjson1_serializeOpDeclineInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 732 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 733) { 734 request, ok := in.Request.(*smithyhttp.Request) 735 if !ok { 736 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 737 } 738 739 input, ok := in.Parameters.(*DeclineInvitationsInput) 740 _ = input 741 if !ok { 742 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 743 } 744 745 opPath, opQuery := httpbinding.SplitURI("/invitations/decline") 746 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 747 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 748 request.Method = "POST" 749 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 750 if err != nil { 751 return out, metadata, &smithy.SerializationError{Err: err} 752 } 753 754 restEncoder.SetHeader("Content-Type").String("application/json") 755 756 jsonEncoder := smithyjson.NewEncoder() 757 if err := awsRestjson1_serializeOpDocumentDeclineInvitationsInput(input, jsonEncoder.Value); err != nil { 758 return out, metadata, &smithy.SerializationError{Err: err} 759 } 760 761 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 762 return out, metadata, &smithy.SerializationError{Err: err} 763 } 764 765 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 766 return out, metadata, &smithy.SerializationError{Err: err} 767 } 768 in.Request = request 769 770 return next.HandleSerialize(ctx, in) 771} 772func awsRestjson1_serializeOpHttpBindingsDeclineInvitationsInput(v *DeclineInvitationsInput, encoder *httpbinding.Encoder) error { 773 if v == nil { 774 return fmt.Errorf("unsupported serialization of nil %T", v) 775 } 776 777 return nil 778} 779 780func awsRestjson1_serializeOpDocumentDeclineInvitationsInput(v *DeclineInvitationsInput, value smithyjson.Value) error { 781 object := value.Object() 782 defer object.Close() 783 784 if v.AccountIds != nil { 785 ok := object.Key("accountIds") 786 if err := awsRestjson1_serializeDocument__listOf__string(v.AccountIds, ok); err != nil { 787 return err 788 } 789 } 790 791 return nil 792} 793 794type awsRestjson1_serializeOpDeleteCustomDataIdentifier struct { 795} 796 797func (*awsRestjson1_serializeOpDeleteCustomDataIdentifier) ID() string { 798 return "OperationSerializer" 799} 800 801func (m *awsRestjson1_serializeOpDeleteCustomDataIdentifier) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 802 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 803) { 804 request, ok := in.Request.(*smithyhttp.Request) 805 if !ok { 806 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 807 } 808 809 input, ok := in.Parameters.(*DeleteCustomDataIdentifierInput) 810 _ = input 811 if !ok { 812 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 813 } 814 815 opPath, opQuery := httpbinding.SplitURI("/custom-data-identifiers/{id}") 816 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 817 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 818 request.Method = "DELETE" 819 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 820 if err != nil { 821 return out, metadata, &smithy.SerializationError{Err: err} 822 } 823 824 if err := awsRestjson1_serializeOpHttpBindingsDeleteCustomDataIdentifierInput(input, restEncoder); err != nil { 825 return out, metadata, &smithy.SerializationError{Err: err} 826 } 827 828 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 829 return out, metadata, &smithy.SerializationError{Err: err} 830 } 831 in.Request = request 832 833 return next.HandleSerialize(ctx, in) 834} 835func awsRestjson1_serializeOpHttpBindingsDeleteCustomDataIdentifierInput(v *DeleteCustomDataIdentifierInput, encoder *httpbinding.Encoder) error { 836 if v == nil { 837 return fmt.Errorf("unsupported serialization of nil %T", v) 838 } 839 840 if v.Id == nil || len(*v.Id) == 0 { 841 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 842 } 843 if v.Id != nil { 844 if err := encoder.SetURI("id").String(*v.Id); err != nil { 845 return err 846 } 847 } 848 849 return nil 850} 851 852type awsRestjson1_serializeOpDeleteFindingsFilter struct { 853} 854 855func (*awsRestjson1_serializeOpDeleteFindingsFilter) ID() string { 856 return "OperationSerializer" 857} 858 859func (m *awsRestjson1_serializeOpDeleteFindingsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 860 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 861) { 862 request, ok := in.Request.(*smithyhttp.Request) 863 if !ok { 864 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 865 } 866 867 input, ok := in.Parameters.(*DeleteFindingsFilterInput) 868 _ = input 869 if !ok { 870 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 871 } 872 873 opPath, opQuery := httpbinding.SplitURI("/findingsfilters/{id}") 874 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 875 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 876 request.Method = "DELETE" 877 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 878 if err != nil { 879 return out, metadata, &smithy.SerializationError{Err: err} 880 } 881 882 if err := awsRestjson1_serializeOpHttpBindingsDeleteFindingsFilterInput(input, restEncoder); err != nil { 883 return out, metadata, &smithy.SerializationError{Err: err} 884 } 885 886 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 887 return out, metadata, &smithy.SerializationError{Err: err} 888 } 889 in.Request = request 890 891 return next.HandleSerialize(ctx, in) 892} 893func awsRestjson1_serializeOpHttpBindingsDeleteFindingsFilterInput(v *DeleteFindingsFilterInput, encoder *httpbinding.Encoder) error { 894 if v == nil { 895 return fmt.Errorf("unsupported serialization of nil %T", v) 896 } 897 898 if v.Id == nil || len(*v.Id) == 0 { 899 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 900 } 901 if v.Id != nil { 902 if err := encoder.SetURI("id").String(*v.Id); err != nil { 903 return err 904 } 905 } 906 907 return nil 908} 909 910type awsRestjson1_serializeOpDeleteInvitations struct { 911} 912 913func (*awsRestjson1_serializeOpDeleteInvitations) ID() string { 914 return "OperationSerializer" 915} 916 917func (m *awsRestjson1_serializeOpDeleteInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 918 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 919) { 920 request, ok := in.Request.(*smithyhttp.Request) 921 if !ok { 922 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 923 } 924 925 input, ok := in.Parameters.(*DeleteInvitationsInput) 926 _ = input 927 if !ok { 928 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 929 } 930 931 opPath, opQuery := httpbinding.SplitURI("/invitations/delete") 932 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 933 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 934 request.Method = "POST" 935 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 936 if err != nil { 937 return out, metadata, &smithy.SerializationError{Err: err} 938 } 939 940 restEncoder.SetHeader("Content-Type").String("application/json") 941 942 jsonEncoder := smithyjson.NewEncoder() 943 if err := awsRestjson1_serializeOpDocumentDeleteInvitationsInput(input, jsonEncoder.Value); err != nil { 944 return out, metadata, &smithy.SerializationError{Err: err} 945 } 946 947 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 948 return out, metadata, &smithy.SerializationError{Err: err} 949 } 950 951 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 952 return out, metadata, &smithy.SerializationError{Err: err} 953 } 954 in.Request = request 955 956 return next.HandleSerialize(ctx, in) 957} 958func awsRestjson1_serializeOpHttpBindingsDeleteInvitationsInput(v *DeleteInvitationsInput, encoder *httpbinding.Encoder) error { 959 if v == nil { 960 return fmt.Errorf("unsupported serialization of nil %T", v) 961 } 962 963 return nil 964} 965 966func awsRestjson1_serializeOpDocumentDeleteInvitationsInput(v *DeleteInvitationsInput, value smithyjson.Value) error { 967 object := value.Object() 968 defer object.Close() 969 970 if v.AccountIds != nil { 971 ok := object.Key("accountIds") 972 if err := awsRestjson1_serializeDocument__listOf__string(v.AccountIds, ok); err != nil { 973 return err 974 } 975 } 976 977 return nil 978} 979 980type awsRestjson1_serializeOpDeleteMember struct { 981} 982 983func (*awsRestjson1_serializeOpDeleteMember) ID() string { 984 return "OperationSerializer" 985} 986 987func (m *awsRestjson1_serializeOpDeleteMember) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 988 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 989) { 990 request, ok := in.Request.(*smithyhttp.Request) 991 if !ok { 992 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 993 } 994 995 input, ok := in.Parameters.(*DeleteMemberInput) 996 _ = input 997 if !ok { 998 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 999 } 1000 1001 opPath, opQuery := httpbinding.SplitURI("/members/{id}") 1002 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1003 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1004 request.Method = "DELETE" 1005 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1006 if err != nil { 1007 return out, metadata, &smithy.SerializationError{Err: err} 1008 } 1009 1010 if err := awsRestjson1_serializeOpHttpBindingsDeleteMemberInput(input, restEncoder); err != nil { 1011 return out, metadata, &smithy.SerializationError{Err: err} 1012 } 1013 1014 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1015 return out, metadata, &smithy.SerializationError{Err: err} 1016 } 1017 in.Request = request 1018 1019 return next.HandleSerialize(ctx, in) 1020} 1021func awsRestjson1_serializeOpHttpBindingsDeleteMemberInput(v *DeleteMemberInput, encoder *httpbinding.Encoder) error { 1022 if v == nil { 1023 return fmt.Errorf("unsupported serialization of nil %T", v) 1024 } 1025 1026 if v.Id == nil || len(*v.Id) == 0 { 1027 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 1028 } 1029 if v.Id != nil { 1030 if err := encoder.SetURI("id").String(*v.Id); err != nil { 1031 return err 1032 } 1033 } 1034 1035 return nil 1036} 1037 1038type awsRestjson1_serializeOpDescribeBuckets struct { 1039} 1040 1041func (*awsRestjson1_serializeOpDescribeBuckets) ID() string { 1042 return "OperationSerializer" 1043} 1044 1045func (m *awsRestjson1_serializeOpDescribeBuckets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1046 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1047) { 1048 request, ok := in.Request.(*smithyhttp.Request) 1049 if !ok { 1050 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1051 } 1052 1053 input, ok := in.Parameters.(*DescribeBucketsInput) 1054 _ = input 1055 if !ok { 1056 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1057 } 1058 1059 opPath, opQuery := httpbinding.SplitURI("/datasources/s3") 1060 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1061 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1062 request.Method = "POST" 1063 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1064 if err != nil { 1065 return out, metadata, &smithy.SerializationError{Err: err} 1066 } 1067 1068 restEncoder.SetHeader("Content-Type").String("application/json") 1069 1070 jsonEncoder := smithyjson.NewEncoder() 1071 if err := awsRestjson1_serializeOpDocumentDescribeBucketsInput(input, jsonEncoder.Value); err != nil { 1072 return out, metadata, &smithy.SerializationError{Err: err} 1073 } 1074 1075 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1076 return out, metadata, &smithy.SerializationError{Err: err} 1077 } 1078 1079 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1080 return out, metadata, &smithy.SerializationError{Err: err} 1081 } 1082 in.Request = request 1083 1084 return next.HandleSerialize(ctx, in) 1085} 1086func awsRestjson1_serializeOpHttpBindingsDescribeBucketsInput(v *DescribeBucketsInput, encoder *httpbinding.Encoder) error { 1087 if v == nil { 1088 return fmt.Errorf("unsupported serialization of nil %T", v) 1089 } 1090 1091 return nil 1092} 1093 1094func awsRestjson1_serializeOpDocumentDescribeBucketsInput(v *DescribeBucketsInput, value smithyjson.Value) error { 1095 object := value.Object() 1096 defer object.Close() 1097 1098 if v.Criteria != nil { 1099 ok := object.Key("criteria") 1100 if err := awsRestjson1_serializeDocumentBucketCriteria(v.Criteria, ok); err != nil { 1101 return err 1102 } 1103 } 1104 1105 if v.MaxResults != 0 { 1106 ok := object.Key("maxResults") 1107 ok.Integer(v.MaxResults) 1108 } 1109 1110 if v.NextToken != nil { 1111 ok := object.Key("nextToken") 1112 ok.String(*v.NextToken) 1113 } 1114 1115 if v.SortCriteria != nil { 1116 ok := object.Key("sortCriteria") 1117 if err := awsRestjson1_serializeDocumentBucketSortCriteria(v.SortCriteria, ok); err != nil { 1118 return err 1119 } 1120 } 1121 1122 return nil 1123} 1124 1125type awsRestjson1_serializeOpDescribeClassificationJob struct { 1126} 1127 1128func (*awsRestjson1_serializeOpDescribeClassificationJob) ID() string { 1129 return "OperationSerializer" 1130} 1131 1132func (m *awsRestjson1_serializeOpDescribeClassificationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1133 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1134) { 1135 request, ok := in.Request.(*smithyhttp.Request) 1136 if !ok { 1137 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1138 } 1139 1140 input, ok := in.Parameters.(*DescribeClassificationJobInput) 1141 _ = input 1142 if !ok { 1143 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1144 } 1145 1146 opPath, opQuery := httpbinding.SplitURI("/jobs/{jobId}") 1147 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1148 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1149 request.Method = "GET" 1150 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1151 if err != nil { 1152 return out, metadata, &smithy.SerializationError{Err: err} 1153 } 1154 1155 if err := awsRestjson1_serializeOpHttpBindingsDescribeClassificationJobInput(input, restEncoder); err != nil { 1156 return out, metadata, &smithy.SerializationError{Err: err} 1157 } 1158 1159 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1160 return out, metadata, &smithy.SerializationError{Err: err} 1161 } 1162 in.Request = request 1163 1164 return next.HandleSerialize(ctx, in) 1165} 1166func awsRestjson1_serializeOpHttpBindingsDescribeClassificationJobInput(v *DescribeClassificationJobInput, encoder *httpbinding.Encoder) error { 1167 if v == nil { 1168 return fmt.Errorf("unsupported serialization of nil %T", v) 1169 } 1170 1171 if v.JobId == nil || len(*v.JobId) == 0 { 1172 return &smithy.SerializationError{Err: fmt.Errorf("input member jobId must not be empty")} 1173 } 1174 if v.JobId != nil { 1175 if err := encoder.SetURI("jobId").String(*v.JobId); err != nil { 1176 return err 1177 } 1178 } 1179 1180 return nil 1181} 1182 1183type awsRestjson1_serializeOpDescribeOrganizationConfiguration struct { 1184} 1185 1186func (*awsRestjson1_serializeOpDescribeOrganizationConfiguration) ID() string { 1187 return "OperationSerializer" 1188} 1189 1190func (m *awsRestjson1_serializeOpDescribeOrganizationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1191 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1192) { 1193 request, ok := in.Request.(*smithyhttp.Request) 1194 if !ok { 1195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1196 } 1197 1198 input, ok := in.Parameters.(*DescribeOrganizationConfigurationInput) 1199 _ = input 1200 if !ok { 1201 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1202 } 1203 1204 opPath, opQuery := httpbinding.SplitURI("/admin/configuration") 1205 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1206 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1207 request.Method = "GET" 1208 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1209 if err != nil { 1210 return out, metadata, &smithy.SerializationError{Err: err} 1211 } 1212 1213 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1214 return out, metadata, &smithy.SerializationError{Err: err} 1215 } 1216 in.Request = request 1217 1218 return next.HandleSerialize(ctx, in) 1219} 1220func awsRestjson1_serializeOpHttpBindingsDescribeOrganizationConfigurationInput(v *DescribeOrganizationConfigurationInput, encoder *httpbinding.Encoder) error { 1221 if v == nil { 1222 return fmt.Errorf("unsupported serialization of nil %T", v) 1223 } 1224 1225 return nil 1226} 1227 1228type awsRestjson1_serializeOpDisableMacie struct { 1229} 1230 1231func (*awsRestjson1_serializeOpDisableMacie) ID() string { 1232 return "OperationSerializer" 1233} 1234 1235func (m *awsRestjson1_serializeOpDisableMacie) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1236 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1237) { 1238 request, ok := in.Request.(*smithyhttp.Request) 1239 if !ok { 1240 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1241 } 1242 1243 input, ok := in.Parameters.(*DisableMacieInput) 1244 _ = input 1245 if !ok { 1246 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1247 } 1248 1249 opPath, opQuery := httpbinding.SplitURI("/macie") 1250 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1251 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1252 request.Method = "DELETE" 1253 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1254 if err != nil { 1255 return out, metadata, &smithy.SerializationError{Err: err} 1256 } 1257 1258 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1259 return out, metadata, &smithy.SerializationError{Err: err} 1260 } 1261 in.Request = request 1262 1263 return next.HandleSerialize(ctx, in) 1264} 1265func awsRestjson1_serializeOpHttpBindingsDisableMacieInput(v *DisableMacieInput, encoder *httpbinding.Encoder) error { 1266 if v == nil { 1267 return fmt.Errorf("unsupported serialization of nil %T", v) 1268 } 1269 1270 return nil 1271} 1272 1273type awsRestjson1_serializeOpDisableOrganizationAdminAccount struct { 1274} 1275 1276func (*awsRestjson1_serializeOpDisableOrganizationAdminAccount) ID() string { 1277 return "OperationSerializer" 1278} 1279 1280func (m *awsRestjson1_serializeOpDisableOrganizationAdminAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1281 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1282) { 1283 request, ok := in.Request.(*smithyhttp.Request) 1284 if !ok { 1285 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1286 } 1287 1288 input, ok := in.Parameters.(*DisableOrganizationAdminAccountInput) 1289 _ = input 1290 if !ok { 1291 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1292 } 1293 1294 opPath, opQuery := httpbinding.SplitURI("/admin") 1295 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1296 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1297 request.Method = "DELETE" 1298 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1299 if err != nil { 1300 return out, metadata, &smithy.SerializationError{Err: err} 1301 } 1302 1303 if err := awsRestjson1_serializeOpHttpBindingsDisableOrganizationAdminAccountInput(input, restEncoder); err != nil { 1304 return out, metadata, &smithy.SerializationError{Err: err} 1305 } 1306 1307 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1308 return out, metadata, &smithy.SerializationError{Err: err} 1309 } 1310 in.Request = request 1311 1312 return next.HandleSerialize(ctx, in) 1313} 1314func awsRestjson1_serializeOpHttpBindingsDisableOrganizationAdminAccountInput(v *DisableOrganizationAdminAccountInput, encoder *httpbinding.Encoder) error { 1315 if v == nil { 1316 return fmt.Errorf("unsupported serialization of nil %T", v) 1317 } 1318 1319 if v.AdminAccountId != nil { 1320 encoder.SetQuery("adminAccountId").String(*v.AdminAccountId) 1321 } 1322 1323 return nil 1324} 1325 1326type awsRestjson1_serializeOpDisassociateFromAdministratorAccount struct { 1327} 1328 1329func (*awsRestjson1_serializeOpDisassociateFromAdministratorAccount) ID() string { 1330 return "OperationSerializer" 1331} 1332 1333func (m *awsRestjson1_serializeOpDisassociateFromAdministratorAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1334 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1335) { 1336 request, ok := in.Request.(*smithyhttp.Request) 1337 if !ok { 1338 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1339 } 1340 1341 input, ok := in.Parameters.(*DisassociateFromAdministratorAccountInput) 1342 _ = input 1343 if !ok { 1344 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1345 } 1346 1347 opPath, opQuery := httpbinding.SplitURI("/administrator/disassociate") 1348 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1349 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1350 request.Method = "POST" 1351 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1352 if err != nil { 1353 return out, metadata, &smithy.SerializationError{Err: err} 1354 } 1355 1356 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1357 return out, metadata, &smithy.SerializationError{Err: err} 1358 } 1359 in.Request = request 1360 1361 return next.HandleSerialize(ctx, in) 1362} 1363func awsRestjson1_serializeOpHttpBindingsDisassociateFromAdministratorAccountInput(v *DisassociateFromAdministratorAccountInput, encoder *httpbinding.Encoder) error { 1364 if v == nil { 1365 return fmt.Errorf("unsupported serialization of nil %T", v) 1366 } 1367 1368 return nil 1369} 1370 1371type awsRestjson1_serializeOpDisassociateFromMasterAccount struct { 1372} 1373 1374func (*awsRestjson1_serializeOpDisassociateFromMasterAccount) ID() string { 1375 return "OperationSerializer" 1376} 1377 1378func (m *awsRestjson1_serializeOpDisassociateFromMasterAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1379 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1380) { 1381 request, ok := in.Request.(*smithyhttp.Request) 1382 if !ok { 1383 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1384 } 1385 1386 input, ok := in.Parameters.(*DisassociateFromMasterAccountInput) 1387 _ = input 1388 if !ok { 1389 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1390 } 1391 1392 opPath, opQuery := httpbinding.SplitURI("/master/disassociate") 1393 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1394 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1395 request.Method = "POST" 1396 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1397 if err != nil { 1398 return out, metadata, &smithy.SerializationError{Err: err} 1399 } 1400 1401 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1402 return out, metadata, &smithy.SerializationError{Err: err} 1403 } 1404 in.Request = request 1405 1406 return next.HandleSerialize(ctx, in) 1407} 1408func awsRestjson1_serializeOpHttpBindingsDisassociateFromMasterAccountInput(v *DisassociateFromMasterAccountInput, encoder *httpbinding.Encoder) error { 1409 if v == nil { 1410 return fmt.Errorf("unsupported serialization of nil %T", v) 1411 } 1412 1413 return nil 1414} 1415 1416type awsRestjson1_serializeOpDisassociateMember struct { 1417} 1418 1419func (*awsRestjson1_serializeOpDisassociateMember) ID() string { 1420 return "OperationSerializer" 1421} 1422 1423func (m *awsRestjson1_serializeOpDisassociateMember) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1424 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1425) { 1426 request, ok := in.Request.(*smithyhttp.Request) 1427 if !ok { 1428 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1429 } 1430 1431 input, ok := in.Parameters.(*DisassociateMemberInput) 1432 _ = input 1433 if !ok { 1434 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1435 } 1436 1437 opPath, opQuery := httpbinding.SplitURI("/members/disassociate/{id}") 1438 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1439 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1440 request.Method = "POST" 1441 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1442 if err != nil { 1443 return out, metadata, &smithy.SerializationError{Err: err} 1444 } 1445 1446 if err := awsRestjson1_serializeOpHttpBindingsDisassociateMemberInput(input, restEncoder); err != nil { 1447 return out, metadata, &smithy.SerializationError{Err: err} 1448 } 1449 1450 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1451 return out, metadata, &smithy.SerializationError{Err: err} 1452 } 1453 in.Request = request 1454 1455 return next.HandleSerialize(ctx, in) 1456} 1457func awsRestjson1_serializeOpHttpBindingsDisassociateMemberInput(v *DisassociateMemberInput, encoder *httpbinding.Encoder) error { 1458 if v == nil { 1459 return fmt.Errorf("unsupported serialization of nil %T", v) 1460 } 1461 1462 if v.Id == nil || len(*v.Id) == 0 { 1463 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 1464 } 1465 if v.Id != nil { 1466 if err := encoder.SetURI("id").String(*v.Id); err != nil { 1467 return err 1468 } 1469 } 1470 1471 return nil 1472} 1473 1474type awsRestjson1_serializeOpEnableMacie struct { 1475} 1476 1477func (*awsRestjson1_serializeOpEnableMacie) ID() string { 1478 return "OperationSerializer" 1479} 1480 1481func (m *awsRestjson1_serializeOpEnableMacie) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1482 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1483) { 1484 request, ok := in.Request.(*smithyhttp.Request) 1485 if !ok { 1486 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1487 } 1488 1489 input, ok := in.Parameters.(*EnableMacieInput) 1490 _ = input 1491 if !ok { 1492 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1493 } 1494 1495 opPath, opQuery := httpbinding.SplitURI("/macie") 1496 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1497 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1498 request.Method = "POST" 1499 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1500 if err != nil { 1501 return out, metadata, &smithy.SerializationError{Err: err} 1502 } 1503 1504 restEncoder.SetHeader("Content-Type").String("application/json") 1505 1506 jsonEncoder := smithyjson.NewEncoder() 1507 if err := awsRestjson1_serializeOpDocumentEnableMacieInput(input, jsonEncoder.Value); err != nil { 1508 return out, metadata, &smithy.SerializationError{Err: err} 1509 } 1510 1511 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1512 return out, metadata, &smithy.SerializationError{Err: err} 1513 } 1514 1515 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1516 return out, metadata, &smithy.SerializationError{Err: err} 1517 } 1518 in.Request = request 1519 1520 return next.HandleSerialize(ctx, in) 1521} 1522func awsRestjson1_serializeOpHttpBindingsEnableMacieInput(v *EnableMacieInput, encoder *httpbinding.Encoder) error { 1523 if v == nil { 1524 return fmt.Errorf("unsupported serialization of nil %T", v) 1525 } 1526 1527 return nil 1528} 1529 1530func awsRestjson1_serializeOpDocumentEnableMacieInput(v *EnableMacieInput, value smithyjson.Value) error { 1531 object := value.Object() 1532 defer object.Close() 1533 1534 if v.ClientToken != nil { 1535 ok := object.Key("clientToken") 1536 ok.String(*v.ClientToken) 1537 } 1538 1539 if len(v.FindingPublishingFrequency) > 0 { 1540 ok := object.Key("findingPublishingFrequency") 1541 ok.String(string(v.FindingPublishingFrequency)) 1542 } 1543 1544 if len(v.Status) > 0 { 1545 ok := object.Key("status") 1546 ok.String(string(v.Status)) 1547 } 1548 1549 return nil 1550} 1551 1552type awsRestjson1_serializeOpEnableOrganizationAdminAccount struct { 1553} 1554 1555func (*awsRestjson1_serializeOpEnableOrganizationAdminAccount) ID() string { 1556 return "OperationSerializer" 1557} 1558 1559func (m *awsRestjson1_serializeOpEnableOrganizationAdminAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1560 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1561) { 1562 request, ok := in.Request.(*smithyhttp.Request) 1563 if !ok { 1564 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1565 } 1566 1567 input, ok := in.Parameters.(*EnableOrganizationAdminAccountInput) 1568 _ = input 1569 if !ok { 1570 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1571 } 1572 1573 opPath, opQuery := httpbinding.SplitURI("/admin") 1574 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1575 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1576 request.Method = "POST" 1577 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1578 if err != nil { 1579 return out, metadata, &smithy.SerializationError{Err: err} 1580 } 1581 1582 restEncoder.SetHeader("Content-Type").String("application/json") 1583 1584 jsonEncoder := smithyjson.NewEncoder() 1585 if err := awsRestjson1_serializeOpDocumentEnableOrganizationAdminAccountInput(input, jsonEncoder.Value); err != nil { 1586 return out, metadata, &smithy.SerializationError{Err: err} 1587 } 1588 1589 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1590 return out, metadata, &smithy.SerializationError{Err: err} 1591 } 1592 1593 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1594 return out, metadata, &smithy.SerializationError{Err: err} 1595 } 1596 in.Request = request 1597 1598 return next.HandleSerialize(ctx, in) 1599} 1600func awsRestjson1_serializeOpHttpBindingsEnableOrganizationAdminAccountInput(v *EnableOrganizationAdminAccountInput, encoder *httpbinding.Encoder) error { 1601 if v == nil { 1602 return fmt.Errorf("unsupported serialization of nil %T", v) 1603 } 1604 1605 return nil 1606} 1607 1608func awsRestjson1_serializeOpDocumentEnableOrganizationAdminAccountInput(v *EnableOrganizationAdminAccountInput, value smithyjson.Value) error { 1609 object := value.Object() 1610 defer object.Close() 1611 1612 if v.AdminAccountId != nil { 1613 ok := object.Key("adminAccountId") 1614 ok.String(*v.AdminAccountId) 1615 } 1616 1617 if v.ClientToken != nil { 1618 ok := object.Key("clientToken") 1619 ok.String(*v.ClientToken) 1620 } 1621 1622 return nil 1623} 1624 1625type awsRestjson1_serializeOpGetAdministratorAccount struct { 1626} 1627 1628func (*awsRestjson1_serializeOpGetAdministratorAccount) ID() string { 1629 return "OperationSerializer" 1630} 1631 1632func (m *awsRestjson1_serializeOpGetAdministratorAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1633 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1634) { 1635 request, ok := in.Request.(*smithyhttp.Request) 1636 if !ok { 1637 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1638 } 1639 1640 input, ok := in.Parameters.(*GetAdministratorAccountInput) 1641 _ = input 1642 if !ok { 1643 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1644 } 1645 1646 opPath, opQuery := httpbinding.SplitURI("/administrator") 1647 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1648 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1649 request.Method = "GET" 1650 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1651 if err != nil { 1652 return out, metadata, &smithy.SerializationError{Err: err} 1653 } 1654 1655 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1656 return out, metadata, &smithy.SerializationError{Err: err} 1657 } 1658 in.Request = request 1659 1660 return next.HandleSerialize(ctx, in) 1661} 1662func awsRestjson1_serializeOpHttpBindingsGetAdministratorAccountInput(v *GetAdministratorAccountInput, encoder *httpbinding.Encoder) error { 1663 if v == nil { 1664 return fmt.Errorf("unsupported serialization of nil %T", v) 1665 } 1666 1667 return nil 1668} 1669 1670type awsRestjson1_serializeOpGetBucketStatistics struct { 1671} 1672 1673func (*awsRestjson1_serializeOpGetBucketStatistics) ID() string { 1674 return "OperationSerializer" 1675} 1676 1677func (m *awsRestjson1_serializeOpGetBucketStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1678 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1679) { 1680 request, ok := in.Request.(*smithyhttp.Request) 1681 if !ok { 1682 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1683 } 1684 1685 input, ok := in.Parameters.(*GetBucketStatisticsInput) 1686 _ = input 1687 if !ok { 1688 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1689 } 1690 1691 opPath, opQuery := httpbinding.SplitURI("/datasources/s3/statistics") 1692 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1693 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1694 request.Method = "POST" 1695 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1696 if err != nil { 1697 return out, metadata, &smithy.SerializationError{Err: err} 1698 } 1699 1700 restEncoder.SetHeader("Content-Type").String("application/json") 1701 1702 jsonEncoder := smithyjson.NewEncoder() 1703 if err := awsRestjson1_serializeOpDocumentGetBucketStatisticsInput(input, jsonEncoder.Value); err != nil { 1704 return out, metadata, &smithy.SerializationError{Err: err} 1705 } 1706 1707 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1708 return out, metadata, &smithy.SerializationError{Err: err} 1709 } 1710 1711 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1712 return out, metadata, &smithy.SerializationError{Err: err} 1713 } 1714 in.Request = request 1715 1716 return next.HandleSerialize(ctx, in) 1717} 1718func awsRestjson1_serializeOpHttpBindingsGetBucketStatisticsInput(v *GetBucketStatisticsInput, encoder *httpbinding.Encoder) error { 1719 if v == nil { 1720 return fmt.Errorf("unsupported serialization of nil %T", v) 1721 } 1722 1723 return nil 1724} 1725 1726func awsRestjson1_serializeOpDocumentGetBucketStatisticsInput(v *GetBucketStatisticsInput, value smithyjson.Value) error { 1727 object := value.Object() 1728 defer object.Close() 1729 1730 if v.AccountId != nil { 1731 ok := object.Key("accountId") 1732 ok.String(*v.AccountId) 1733 } 1734 1735 return nil 1736} 1737 1738type awsRestjson1_serializeOpGetClassificationExportConfiguration struct { 1739} 1740 1741func (*awsRestjson1_serializeOpGetClassificationExportConfiguration) ID() string { 1742 return "OperationSerializer" 1743} 1744 1745func (m *awsRestjson1_serializeOpGetClassificationExportConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1746 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1747) { 1748 request, ok := in.Request.(*smithyhttp.Request) 1749 if !ok { 1750 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1751 } 1752 1753 input, ok := in.Parameters.(*GetClassificationExportConfigurationInput) 1754 _ = input 1755 if !ok { 1756 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1757 } 1758 1759 opPath, opQuery := httpbinding.SplitURI("/classification-export-configuration") 1760 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1761 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1762 request.Method = "GET" 1763 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1764 if err != nil { 1765 return out, metadata, &smithy.SerializationError{Err: err} 1766 } 1767 1768 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1769 return out, metadata, &smithy.SerializationError{Err: err} 1770 } 1771 in.Request = request 1772 1773 return next.HandleSerialize(ctx, in) 1774} 1775func awsRestjson1_serializeOpHttpBindingsGetClassificationExportConfigurationInput(v *GetClassificationExportConfigurationInput, encoder *httpbinding.Encoder) error { 1776 if v == nil { 1777 return fmt.Errorf("unsupported serialization of nil %T", v) 1778 } 1779 1780 return nil 1781} 1782 1783type awsRestjson1_serializeOpGetCustomDataIdentifier struct { 1784} 1785 1786func (*awsRestjson1_serializeOpGetCustomDataIdentifier) ID() string { 1787 return "OperationSerializer" 1788} 1789 1790func (m *awsRestjson1_serializeOpGetCustomDataIdentifier) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1791 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1792) { 1793 request, ok := in.Request.(*smithyhttp.Request) 1794 if !ok { 1795 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1796 } 1797 1798 input, ok := in.Parameters.(*GetCustomDataIdentifierInput) 1799 _ = input 1800 if !ok { 1801 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1802 } 1803 1804 opPath, opQuery := httpbinding.SplitURI("/custom-data-identifiers/{id}") 1805 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1806 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1807 request.Method = "GET" 1808 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1809 if err != nil { 1810 return out, metadata, &smithy.SerializationError{Err: err} 1811 } 1812 1813 if err := awsRestjson1_serializeOpHttpBindingsGetCustomDataIdentifierInput(input, restEncoder); err != nil { 1814 return out, metadata, &smithy.SerializationError{Err: err} 1815 } 1816 1817 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1818 return out, metadata, &smithy.SerializationError{Err: err} 1819 } 1820 in.Request = request 1821 1822 return next.HandleSerialize(ctx, in) 1823} 1824func awsRestjson1_serializeOpHttpBindingsGetCustomDataIdentifierInput(v *GetCustomDataIdentifierInput, encoder *httpbinding.Encoder) error { 1825 if v == nil { 1826 return fmt.Errorf("unsupported serialization of nil %T", v) 1827 } 1828 1829 if v.Id == nil || len(*v.Id) == 0 { 1830 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 1831 } 1832 if v.Id != nil { 1833 if err := encoder.SetURI("id").String(*v.Id); err != nil { 1834 return err 1835 } 1836 } 1837 1838 return nil 1839} 1840 1841type awsRestjson1_serializeOpGetFindings struct { 1842} 1843 1844func (*awsRestjson1_serializeOpGetFindings) ID() string { 1845 return "OperationSerializer" 1846} 1847 1848func (m *awsRestjson1_serializeOpGetFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1849 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1850) { 1851 request, ok := in.Request.(*smithyhttp.Request) 1852 if !ok { 1853 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1854 } 1855 1856 input, ok := in.Parameters.(*GetFindingsInput) 1857 _ = input 1858 if !ok { 1859 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1860 } 1861 1862 opPath, opQuery := httpbinding.SplitURI("/findings/describe") 1863 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1864 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1865 request.Method = "POST" 1866 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1867 if err != nil { 1868 return out, metadata, &smithy.SerializationError{Err: err} 1869 } 1870 1871 restEncoder.SetHeader("Content-Type").String("application/json") 1872 1873 jsonEncoder := smithyjson.NewEncoder() 1874 if err := awsRestjson1_serializeOpDocumentGetFindingsInput(input, jsonEncoder.Value); err != nil { 1875 return out, metadata, &smithy.SerializationError{Err: err} 1876 } 1877 1878 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1879 return out, metadata, &smithy.SerializationError{Err: err} 1880 } 1881 1882 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1883 return out, metadata, &smithy.SerializationError{Err: err} 1884 } 1885 in.Request = request 1886 1887 return next.HandleSerialize(ctx, in) 1888} 1889func awsRestjson1_serializeOpHttpBindingsGetFindingsInput(v *GetFindingsInput, encoder *httpbinding.Encoder) error { 1890 if v == nil { 1891 return fmt.Errorf("unsupported serialization of nil %T", v) 1892 } 1893 1894 return nil 1895} 1896 1897func awsRestjson1_serializeOpDocumentGetFindingsInput(v *GetFindingsInput, value smithyjson.Value) error { 1898 object := value.Object() 1899 defer object.Close() 1900 1901 if v.FindingIds != nil { 1902 ok := object.Key("findingIds") 1903 if err := awsRestjson1_serializeDocument__listOf__string(v.FindingIds, ok); err != nil { 1904 return err 1905 } 1906 } 1907 1908 if v.SortCriteria != nil { 1909 ok := object.Key("sortCriteria") 1910 if err := awsRestjson1_serializeDocumentSortCriteria(v.SortCriteria, ok); err != nil { 1911 return err 1912 } 1913 } 1914 1915 return nil 1916} 1917 1918type awsRestjson1_serializeOpGetFindingsFilter struct { 1919} 1920 1921func (*awsRestjson1_serializeOpGetFindingsFilter) ID() string { 1922 return "OperationSerializer" 1923} 1924 1925func (m *awsRestjson1_serializeOpGetFindingsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1926 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1927) { 1928 request, ok := in.Request.(*smithyhttp.Request) 1929 if !ok { 1930 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1931 } 1932 1933 input, ok := in.Parameters.(*GetFindingsFilterInput) 1934 _ = input 1935 if !ok { 1936 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1937 } 1938 1939 opPath, opQuery := httpbinding.SplitURI("/findingsfilters/{id}") 1940 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1941 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1942 request.Method = "GET" 1943 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1944 if err != nil { 1945 return out, metadata, &smithy.SerializationError{Err: err} 1946 } 1947 1948 if err := awsRestjson1_serializeOpHttpBindingsGetFindingsFilterInput(input, restEncoder); err != nil { 1949 return out, metadata, &smithy.SerializationError{Err: err} 1950 } 1951 1952 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1953 return out, metadata, &smithy.SerializationError{Err: err} 1954 } 1955 in.Request = request 1956 1957 return next.HandleSerialize(ctx, in) 1958} 1959func awsRestjson1_serializeOpHttpBindingsGetFindingsFilterInput(v *GetFindingsFilterInput, encoder *httpbinding.Encoder) error { 1960 if v == nil { 1961 return fmt.Errorf("unsupported serialization of nil %T", v) 1962 } 1963 1964 if v.Id == nil || len(*v.Id) == 0 { 1965 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 1966 } 1967 if v.Id != nil { 1968 if err := encoder.SetURI("id").String(*v.Id); err != nil { 1969 return err 1970 } 1971 } 1972 1973 return nil 1974} 1975 1976type awsRestjson1_serializeOpGetFindingsPublicationConfiguration struct { 1977} 1978 1979func (*awsRestjson1_serializeOpGetFindingsPublicationConfiguration) ID() string { 1980 return "OperationSerializer" 1981} 1982 1983func (m *awsRestjson1_serializeOpGetFindingsPublicationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1984 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1985) { 1986 request, ok := in.Request.(*smithyhttp.Request) 1987 if !ok { 1988 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1989 } 1990 1991 input, ok := in.Parameters.(*GetFindingsPublicationConfigurationInput) 1992 _ = input 1993 if !ok { 1994 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1995 } 1996 1997 opPath, opQuery := httpbinding.SplitURI("/findings-publication-configuration") 1998 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1999 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2000 request.Method = "GET" 2001 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2002 if err != nil { 2003 return out, metadata, &smithy.SerializationError{Err: err} 2004 } 2005 2006 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2007 return out, metadata, &smithy.SerializationError{Err: err} 2008 } 2009 in.Request = request 2010 2011 return next.HandleSerialize(ctx, in) 2012} 2013func awsRestjson1_serializeOpHttpBindingsGetFindingsPublicationConfigurationInput(v *GetFindingsPublicationConfigurationInput, encoder *httpbinding.Encoder) error { 2014 if v == nil { 2015 return fmt.Errorf("unsupported serialization of nil %T", v) 2016 } 2017 2018 return nil 2019} 2020 2021type awsRestjson1_serializeOpGetFindingStatistics struct { 2022} 2023 2024func (*awsRestjson1_serializeOpGetFindingStatistics) ID() string { 2025 return "OperationSerializer" 2026} 2027 2028func (m *awsRestjson1_serializeOpGetFindingStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2029 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2030) { 2031 request, ok := in.Request.(*smithyhttp.Request) 2032 if !ok { 2033 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2034 } 2035 2036 input, ok := in.Parameters.(*GetFindingStatisticsInput) 2037 _ = input 2038 if !ok { 2039 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2040 } 2041 2042 opPath, opQuery := httpbinding.SplitURI("/findings/statistics") 2043 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2044 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2045 request.Method = "POST" 2046 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2047 if err != nil { 2048 return out, metadata, &smithy.SerializationError{Err: err} 2049 } 2050 2051 restEncoder.SetHeader("Content-Type").String("application/json") 2052 2053 jsonEncoder := smithyjson.NewEncoder() 2054 if err := awsRestjson1_serializeOpDocumentGetFindingStatisticsInput(input, jsonEncoder.Value); err != nil { 2055 return out, metadata, &smithy.SerializationError{Err: err} 2056 } 2057 2058 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2059 return out, metadata, &smithy.SerializationError{Err: err} 2060 } 2061 2062 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2063 return out, metadata, &smithy.SerializationError{Err: err} 2064 } 2065 in.Request = request 2066 2067 return next.HandleSerialize(ctx, in) 2068} 2069func awsRestjson1_serializeOpHttpBindingsGetFindingStatisticsInput(v *GetFindingStatisticsInput, encoder *httpbinding.Encoder) error { 2070 if v == nil { 2071 return fmt.Errorf("unsupported serialization of nil %T", v) 2072 } 2073 2074 return nil 2075} 2076 2077func awsRestjson1_serializeOpDocumentGetFindingStatisticsInput(v *GetFindingStatisticsInput, value smithyjson.Value) error { 2078 object := value.Object() 2079 defer object.Close() 2080 2081 if v.FindingCriteria != nil { 2082 ok := object.Key("findingCriteria") 2083 if err := awsRestjson1_serializeDocumentFindingCriteria(v.FindingCriteria, ok); err != nil { 2084 return err 2085 } 2086 } 2087 2088 if len(v.GroupBy) > 0 { 2089 ok := object.Key("groupBy") 2090 ok.String(string(v.GroupBy)) 2091 } 2092 2093 if v.Size != 0 { 2094 ok := object.Key("size") 2095 ok.Integer(v.Size) 2096 } 2097 2098 if v.SortCriteria != nil { 2099 ok := object.Key("sortCriteria") 2100 if err := awsRestjson1_serializeDocumentFindingStatisticsSortCriteria(v.SortCriteria, ok); err != nil { 2101 return err 2102 } 2103 } 2104 2105 return nil 2106} 2107 2108type awsRestjson1_serializeOpGetInvitationsCount struct { 2109} 2110 2111func (*awsRestjson1_serializeOpGetInvitationsCount) ID() string { 2112 return "OperationSerializer" 2113} 2114 2115func (m *awsRestjson1_serializeOpGetInvitationsCount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2116 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2117) { 2118 request, ok := in.Request.(*smithyhttp.Request) 2119 if !ok { 2120 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2121 } 2122 2123 input, ok := in.Parameters.(*GetInvitationsCountInput) 2124 _ = input 2125 if !ok { 2126 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2127 } 2128 2129 opPath, opQuery := httpbinding.SplitURI("/invitations/count") 2130 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2131 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2132 request.Method = "GET" 2133 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2134 if err != nil { 2135 return out, metadata, &smithy.SerializationError{Err: err} 2136 } 2137 2138 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2139 return out, metadata, &smithy.SerializationError{Err: err} 2140 } 2141 in.Request = request 2142 2143 return next.HandleSerialize(ctx, in) 2144} 2145func awsRestjson1_serializeOpHttpBindingsGetInvitationsCountInput(v *GetInvitationsCountInput, encoder *httpbinding.Encoder) error { 2146 if v == nil { 2147 return fmt.Errorf("unsupported serialization of nil %T", v) 2148 } 2149 2150 return nil 2151} 2152 2153type awsRestjson1_serializeOpGetMacieSession struct { 2154} 2155 2156func (*awsRestjson1_serializeOpGetMacieSession) ID() string { 2157 return "OperationSerializer" 2158} 2159 2160func (m *awsRestjson1_serializeOpGetMacieSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2161 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2162) { 2163 request, ok := in.Request.(*smithyhttp.Request) 2164 if !ok { 2165 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2166 } 2167 2168 input, ok := in.Parameters.(*GetMacieSessionInput) 2169 _ = input 2170 if !ok { 2171 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2172 } 2173 2174 opPath, opQuery := httpbinding.SplitURI("/macie") 2175 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2176 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2177 request.Method = "GET" 2178 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2179 if err != nil { 2180 return out, metadata, &smithy.SerializationError{Err: err} 2181 } 2182 2183 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2184 return out, metadata, &smithy.SerializationError{Err: err} 2185 } 2186 in.Request = request 2187 2188 return next.HandleSerialize(ctx, in) 2189} 2190func awsRestjson1_serializeOpHttpBindingsGetMacieSessionInput(v *GetMacieSessionInput, encoder *httpbinding.Encoder) error { 2191 if v == nil { 2192 return fmt.Errorf("unsupported serialization of nil %T", v) 2193 } 2194 2195 return nil 2196} 2197 2198type awsRestjson1_serializeOpGetMasterAccount struct { 2199} 2200 2201func (*awsRestjson1_serializeOpGetMasterAccount) ID() string { 2202 return "OperationSerializer" 2203} 2204 2205func (m *awsRestjson1_serializeOpGetMasterAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2206 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2207) { 2208 request, ok := in.Request.(*smithyhttp.Request) 2209 if !ok { 2210 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2211 } 2212 2213 input, ok := in.Parameters.(*GetMasterAccountInput) 2214 _ = input 2215 if !ok { 2216 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2217 } 2218 2219 opPath, opQuery := httpbinding.SplitURI("/master") 2220 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2221 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2222 request.Method = "GET" 2223 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2224 if err != nil { 2225 return out, metadata, &smithy.SerializationError{Err: err} 2226 } 2227 2228 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2229 return out, metadata, &smithy.SerializationError{Err: err} 2230 } 2231 in.Request = request 2232 2233 return next.HandleSerialize(ctx, in) 2234} 2235func awsRestjson1_serializeOpHttpBindingsGetMasterAccountInput(v *GetMasterAccountInput, encoder *httpbinding.Encoder) error { 2236 if v == nil { 2237 return fmt.Errorf("unsupported serialization of nil %T", v) 2238 } 2239 2240 return nil 2241} 2242 2243type awsRestjson1_serializeOpGetMember struct { 2244} 2245 2246func (*awsRestjson1_serializeOpGetMember) ID() string { 2247 return "OperationSerializer" 2248} 2249 2250func (m *awsRestjson1_serializeOpGetMember) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2251 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2252) { 2253 request, ok := in.Request.(*smithyhttp.Request) 2254 if !ok { 2255 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2256 } 2257 2258 input, ok := in.Parameters.(*GetMemberInput) 2259 _ = input 2260 if !ok { 2261 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2262 } 2263 2264 opPath, opQuery := httpbinding.SplitURI("/members/{id}") 2265 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2266 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2267 request.Method = "GET" 2268 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2269 if err != nil { 2270 return out, metadata, &smithy.SerializationError{Err: err} 2271 } 2272 2273 if err := awsRestjson1_serializeOpHttpBindingsGetMemberInput(input, restEncoder); err != nil { 2274 return out, metadata, &smithy.SerializationError{Err: err} 2275 } 2276 2277 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2278 return out, metadata, &smithy.SerializationError{Err: err} 2279 } 2280 in.Request = request 2281 2282 return next.HandleSerialize(ctx, in) 2283} 2284func awsRestjson1_serializeOpHttpBindingsGetMemberInput(v *GetMemberInput, encoder *httpbinding.Encoder) error { 2285 if v == nil { 2286 return fmt.Errorf("unsupported serialization of nil %T", v) 2287 } 2288 2289 if v.Id == nil || len(*v.Id) == 0 { 2290 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 2291 } 2292 if v.Id != nil { 2293 if err := encoder.SetURI("id").String(*v.Id); err != nil { 2294 return err 2295 } 2296 } 2297 2298 return nil 2299} 2300 2301type awsRestjson1_serializeOpGetUsageStatistics struct { 2302} 2303 2304func (*awsRestjson1_serializeOpGetUsageStatistics) ID() string { 2305 return "OperationSerializer" 2306} 2307 2308func (m *awsRestjson1_serializeOpGetUsageStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2309 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2310) { 2311 request, ok := in.Request.(*smithyhttp.Request) 2312 if !ok { 2313 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2314 } 2315 2316 input, ok := in.Parameters.(*GetUsageStatisticsInput) 2317 _ = input 2318 if !ok { 2319 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2320 } 2321 2322 opPath, opQuery := httpbinding.SplitURI("/usage/statistics") 2323 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2324 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2325 request.Method = "POST" 2326 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2327 if err != nil { 2328 return out, metadata, &smithy.SerializationError{Err: err} 2329 } 2330 2331 restEncoder.SetHeader("Content-Type").String("application/json") 2332 2333 jsonEncoder := smithyjson.NewEncoder() 2334 if err := awsRestjson1_serializeOpDocumentGetUsageStatisticsInput(input, jsonEncoder.Value); err != nil { 2335 return out, metadata, &smithy.SerializationError{Err: err} 2336 } 2337 2338 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2339 return out, metadata, &smithy.SerializationError{Err: err} 2340 } 2341 2342 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2343 return out, metadata, &smithy.SerializationError{Err: err} 2344 } 2345 in.Request = request 2346 2347 return next.HandleSerialize(ctx, in) 2348} 2349func awsRestjson1_serializeOpHttpBindingsGetUsageStatisticsInput(v *GetUsageStatisticsInput, encoder *httpbinding.Encoder) error { 2350 if v == nil { 2351 return fmt.Errorf("unsupported serialization of nil %T", v) 2352 } 2353 2354 return nil 2355} 2356 2357func awsRestjson1_serializeOpDocumentGetUsageStatisticsInput(v *GetUsageStatisticsInput, value smithyjson.Value) error { 2358 object := value.Object() 2359 defer object.Close() 2360 2361 if v.FilterBy != nil { 2362 ok := object.Key("filterBy") 2363 if err := awsRestjson1_serializeDocument__listOfUsageStatisticsFilter(v.FilterBy, ok); err != nil { 2364 return err 2365 } 2366 } 2367 2368 if v.MaxResults != 0 { 2369 ok := object.Key("maxResults") 2370 ok.Integer(v.MaxResults) 2371 } 2372 2373 if v.NextToken != nil { 2374 ok := object.Key("nextToken") 2375 ok.String(*v.NextToken) 2376 } 2377 2378 if v.SortBy != nil { 2379 ok := object.Key("sortBy") 2380 if err := awsRestjson1_serializeDocumentUsageStatisticsSortBy(v.SortBy, ok); err != nil { 2381 return err 2382 } 2383 } 2384 2385 if len(v.TimeRange) > 0 { 2386 ok := object.Key("timeRange") 2387 ok.String(string(v.TimeRange)) 2388 } 2389 2390 return nil 2391} 2392 2393type awsRestjson1_serializeOpGetUsageTotals struct { 2394} 2395 2396func (*awsRestjson1_serializeOpGetUsageTotals) ID() string { 2397 return "OperationSerializer" 2398} 2399 2400func (m *awsRestjson1_serializeOpGetUsageTotals) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2401 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2402) { 2403 request, ok := in.Request.(*smithyhttp.Request) 2404 if !ok { 2405 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2406 } 2407 2408 input, ok := in.Parameters.(*GetUsageTotalsInput) 2409 _ = input 2410 if !ok { 2411 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2412 } 2413 2414 opPath, opQuery := httpbinding.SplitURI("/usage") 2415 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2416 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2417 request.Method = "GET" 2418 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2419 if err != nil { 2420 return out, metadata, &smithy.SerializationError{Err: err} 2421 } 2422 2423 if err := awsRestjson1_serializeOpHttpBindingsGetUsageTotalsInput(input, restEncoder); err != nil { 2424 return out, metadata, &smithy.SerializationError{Err: err} 2425 } 2426 2427 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2428 return out, metadata, &smithy.SerializationError{Err: err} 2429 } 2430 in.Request = request 2431 2432 return next.HandleSerialize(ctx, in) 2433} 2434func awsRestjson1_serializeOpHttpBindingsGetUsageTotalsInput(v *GetUsageTotalsInput, encoder *httpbinding.Encoder) error { 2435 if v == nil { 2436 return fmt.Errorf("unsupported serialization of nil %T", v) 2437 } 2438 2439 if v.TimeRange != nil { 2440 encoder.SetQuery("timeRange").String(*v.TimeRange) 2441 } 2442 2443 return nil 2444} 2445 2446type awsRestjson1_serializeOpListClassificationJobs struct { 2447} 2448 2449func (*awsRestjson1_serializeOpListClassificationJobs) ID() string { 2450 return "OperationSerializer" 2451} 2452 2453func (m *awsRestjson1_serializeOpListClassificationJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2454 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2455) { 2456 request, ok := in.Request.(*smithyhttp.Request) 2457 if !ok { 2458 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2459 } 2460 2461 input, ok := in.Parameters.(*ListClassificationJobsInput) 2462 _ = input 2463 if !ok { 2464 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2465 } 2466 2467 opPath, opQuery := httpbinding.SplitURI("/jobs/list") 2468 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2469 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2470 request.Method = "POST" 2471 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2472 if err != nil { 2473 return out, metadata, &smithy.SerializationError{Err: err} 2474 } 2475 2476 restEncoder.SetHeader("Content-Type").String("application/json") 2477 2478 jsonEncoder := smithyjson.NewEncoder() 2479 if err := awsRestjson1_serializeOpDocumentListClassificationJobsInput(input, jsonEncoder.Value); err != nil { 2480 return out, metadata, &smithy.SerializationError{Err: err} 2481 } 2482 2483 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2484 return out, metadata, &smithy.SerializationError{Err: err} 2485 } 2486 2487 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2488 return out, metadata, &smithy.SerializationError{Err: err} 2489 } 2490 in.Request = request 2491 2492 return next.HandleSerialize(ctx, in) 2493} 2494func awsRestjson1_serializeOpHttpBindingsListClassificationJobsInput(v *ListClassificationJobsInput, encoder *httpbinding.Encoder) error { 2495 if v == nil { 2496 return fmt.Errorf("unsupported serialization of nil %T", v) 2497 } 2498 2499 return nil 2500} 2501 2502func awsRestjson1_serializeOpDocumentListClassificationJobsInput(v *ListClassificationJobsInput, value smithyjson.Value) error { 2503 object := value.Object() 2504 defer object.Close() 2505 2506 if v.FilterCriteria != nil { 2507 ok := object.Key("filterCriteria") 2508 if err := awsRestjson1_serializeDocumentListJobsFilterCriteria(v.FilterCriteria, ok); err != nil { 2509 return err 2510 } 2511 } 2512 2513 if v.MaxResults != 0 { 2514 ok := object.Key("maxResults") 2515 ok.Integer(v.MaxResults) 2516 } 2517 2518 if v.NextToken != nil { 2519 ok := object.Key("nextToken") 2520 ok.String(*v.NextToken) 2521 } 2522 2523 if v.SortCriteria != nil { 2524 ok := object.Key("sortCriteria") 2525 if err := awsRestjson1_serializeDocumentListJobsSortCriteria(v.SortCriteria, ok); err != nil { 2526 return err 2527 } 2528 } 2529 2530 return nil 2531} 2532 2533type awsRestjson1_serializeOpListCustomDataIdentifiers struct { 2534} 2535 2536func (*awsRestjson1_serializeOpListCustomDataIdentifiers) ID() string { 2537 return "OperationSerializer" 2538} 2539 2540func (m *awsRestjson1_serializeOpListCustomDataIdentifiers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2541 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2542) { 2543 request, ok := in.Request.(*smithyhttp.Request) 2544 if !ok { 2545 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2546 } 2547 2548 input, ok := in.Parameters.(*ListCustomDataIdentifiersInput) 2549 _ = input 2550 if !ok { 2551 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2552 } 2553 2554 opPath, opQuery := httpbinding.SplitURI("/custom-data-identifiers/list") 2555 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2556 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2557 request.Method = "POST" 2558 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2559 if err != nil { 2560 return out, metadata, &smithy.SerializationError{Err: err} 2561 } 2562 2563 restEncoder.SetHeader("Content-Type").String("application/json") 2564 2565 jsonEncoder := smithyjson.NewEncoder() 2566 if err := awsRestjson1_serializeOpDocumentListCustomDataIdentifiersInput(input, jsonEncoder.Value); err != nil { 2567 return out, metadata, &smithy.SerializationError{Err: err} 2568 } 2569 2570 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2571 return out, metadata, &smithy.SerializationError{Err: err} 2572 } 2573 2574 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2575 return out, metadata, &smithy.SerializationError{Err: err} 2576 } 2577 in.Request = request 2578 2579 return next.HandleSerialize(ctx, in) 2580} 2581func awsRestjson1_serializeOpHttpBindingsListCustomDataIdentifiersInput(v *ListCustomDataIdentifiersInput, encoder *httpbinding.Encoder) error { 2582 if v == nil { 2583 return fmt.Errorf("unsupported serialization of nil %T", v) 2584 } 2585 2586 return nil 2587} 2588 2589func awsRestjson1_serializeOpDocumentListCustomDataIdentifiersInput(v *ListCustomDataIdentifiersInput, value smithyjson.Value) error { 2590 object := value.Object() 2591 defer object.Close() 2592 2593 if v.MaxResults != 0 { 2594 ok := object.Key("maxResults") 2595 ok.Integer(v.MaxResults) 2596 } 2597 2598 if v.NextToken != nil { 2599 ok := object.Key("nextToken") 2600 ok.String(*v.NextToken) 2601 } 2602 2603 return nil 2604} 2605 2606type awsRestjson1_serializeOpListFindings struct { 2607} 2608 2609func (*awsRestjson1_serializeOpListFindings) ID() string { 2610 return "OperationSerializer" 2611} 2612 2613func (m *awsRestjson1_serializeOpListFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2614 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2615) { 2616 request, ok := in.Request.(*smithyhttp.Request) 2617 if !ok { 2618 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2619 } 2620 2621 input, ok := in.Parameters.(*ListFindingsInput) 2622 _ = input 2623 if !ok { 2624 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2625 } 2626 2627 opPath, opQuery := httpbinding.SplitURI("/findings") 2628 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2629 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2630 request.Method = "POST" 2631 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2632 if err != nil { 2633 return out, metadata, &smithy.SerializationError{Err: err} 2634 } 2635 2636 restEncoder.SetHeader("Content-Type").String("application/json") 2637 2638 jsonEncoder := smithyjson.NewEncoder() 2639 if err := awsRestjson1_serializeOpDocumentListFindingsInput(input, jsonEncoder.Value); err != nil { 2640 return out, metadata, &smithy.SerializationError{Err: err} 2641 } 2642 2643 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2644 return out, metadata, &smithy.SerializationError{Err: err} 2645 } 2646 2647 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2648 return out, metadata, &smithy.SerializationError{Err: err} 2649 } 2650 in.Request = request 2651 2652 return next.HandleSerialize(ctx, in) 2653} 2654func awsRestjson1_serializeOpHttpBindingsListFindingsInput(v *ListFindingsInput, encoder *httpbinding.Encoder) error { 2655 if v == nil { 2656 return fmt.Errorf("unsupported serialization of nil %T", v) 2657 } 2658 2659 return nil 2660} 2661 2662func awsRestjson1_serializeOpDocumentListFindingsInput(v *ListFindingsInput, value smithyjson.Value) error { 2663 object := value.Object() 2664 defer object.Close() 2665 2666 if v.FindingCriteria != nil { 2667 ok := object.Key("findingCriteria") 2668 if err := awsRestjson1_serializeDocumentFindingCriteria(v.FindingCriteria, ok); err != nil { 2669 return err 2670 } 2671 } 2672 2673 if v.MaxResults != 0 { 2674 ok := object.Key("maxResults") 2675 ok.Integer(v.MaxResults) 2676 } 2677 2678 if v.NextToken != nil { 2679 ok := object.Key("nextToken") 2680 ok.String(*v.NextToken) 2681 } 2682 2683 if v.SortCriteria != nil { 2684 ok := object.Key("sortCriteria") 2685 if err := awsRestjson1_serializeDocumentSortCriteria(v.SortCriteria, ok); err != nil { 2686 return err 2687 } 2688 } 2689 2690 return nil 2691} 2692 2693type awsRestjson1_serializeOpListFindingsFilters struct { 2694} 2695 2696func (*awsRestjson1_serializeOpListFindingsFilters) ID() string { 2697 return "OperationSerializer" 2698} 2699 2700func (m *awsRestjson1_serializeOpListFindingsFilters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2701 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2702) { 2703 request, ok := in.Request.(*smithyhttp.Request) 2704 if !ok { 2705 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2706 } 2707 2708 input, ok := in.Parameters.(*ListFindingsFiltersInput) 2709 _ = input 2710 if !ok { 2711 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2712 } 2713 2714 opPath, opQuery := httpbinding.SplitURI("/findingsfilters") 2715 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2716 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2717 request.Method = "GET" 2718 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2719 if err != nil { 2720 return out, metadata, &smithy.SerializationError{Err: err} 2721 } 2722 2723 if err := awsRestjson1_serializeOpHttpBindingsListFindingsFiltersInput(input, restEncoder); err != nil { 2724 return out, metadata, &smithy.SerializationError{Err: err} 2725 } 2726 2727 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2728 return out, metadata, &smithy.SerializationError{Err: err} 2729 } 2730 in.Request = request 2731 2732 return next.HandleSerialize(ctx, in) 2733} 2734func awsRestjson1_serializeOpHttpBindingsListFindingsFiltersInput(v *ListFindingsFiltersInput, encoder *httpbinding.Encoder) error { 2735 if v == nil { 2736 return fmt.Errorf("unsupported serialization of nil %T", v) 2737 } 2738 2739 if v.MaxResults != 0 { 2740 encoder.SetQuery("maxResults").Integer(v.MaxResults) 2741 } 2742 2743 if v.NextToken != nil { 2744 encoder.SetQuery("nextToken").String(*v.NextToken) 2745 } 2746 2747 return nil 2748} 2749 2750type awsRestjson1_serializeOpListInvitations struct { 2751} 2752 2753func (*awsRestjson1_serializeOpListInvitations) ID() string { 2754 return "OperationSerializer" 2755} 2756 2757func (m *awsRestjson1_serializeOpListInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2758 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2759) { 2760 request, ok := in.Request.(*smithyhttp.Request) 2761 if !ok { 2762 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2763 } 2764 2765 input, ok := in.Parameters.(*ListInvitationsInput) 2766 _ = input 2767 if !ok { 2768 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2769 } 2770 2771 opPath, opQuery := httpbinding.SplitURI("/invitations") 2772 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2773 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2774 request.Method = "GET" 2775 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2776 if err != nil { 2777 return out, metadata, &smithy.SerializationError{Err: err} 2778 } 2779 2780 if err := awsRestjson1_serializeOpHttpBindingsListInvitationsInput(input, restEncoder); err != nil { 2781 return out, metadata, &smithy.SerializationError{Err: err} 2782 } 2783 2784 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2785 return out, metadata, &smithy.SerializationError{Err: err} 2786 } 2787 in.Request = request 2788 2789 return next.HandleSerialize(ctx, in) 2790} 2791func awsRestjson1_serializeOpHttpBindingsListInvitationsInput(v *ListInvitationsInput, encoder *httpbinding.Encoder) error { 2792 if v == nil { 2793 return fmt.Errorf("unsupported serialization of nil %T", v) 2794 } 2795 2796 if v.MaxResults != 0 { 2797 encoder.SetQuery("maxResults").Integer(v.MaxResults) 2798 } 2799 2800 if v.NextToken != nil { 2801 encoder.SetQuery("nextToken").String(*v.NextToken) 2802 } 2803 2804 return nil 2805} 2806 2807type awsRestjson1_serializeOpListMembers struct { 2808} 2809 2810func (*awsRestjson1_serializeOpListMembers) ID() string { 2811 return "OperationSerializer" 2812} 2813 2814func (m *awsRestjson1_serializeOpListMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2815 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2816) { 2817 request, ok := in.Request.(*smithyhttp.Request) 2818 if !ok { 2819 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2820 } 2821 2822 input, ok := in.Parameters.(*ListMembersInput) 2823 _ = input 2824 if !ok { 2825 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2826 } 2827 2828 opPath, opQuery := httpbinding.SplitURI("/members") 2829 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2830 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2831 request.Method = "GET" 2832 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2833 if err != nil { 2834 return out, metadata, &smithy.SerializationError{Err: err} 2835 } 2836 2837 if err := awsRestjson1_serializeOpHttpBindingsListMembersInput(input, restEncoder); err != nil { 2838 return out, metadata, &smithy.SerializationError{Err: err} 2839 } 2840 2841 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2842 return out, metadata, &smithy.SerializationError{Err: err} 2843 } 2844 in.Request = request 2845 2846 return next.HandleSerialize(ctx, in) 2847} 2848func awsRestjson1_serializeOpHttpBindingsListMembersInput(v *ListMembersInput, encoder *httpbinding.Encoder) error { 2849 if v == nil { 2850 return fmt.Errorf("unsupported serialization of nil %T", v) 2851 } 2852 2853 if v.MaxResults != 0 { 2854 encoder.SetQuery("maxResults").Integer(v.MaxResults) 2855 } 2856 2857 if v.NextToken != nil { 2858 encoder.SetQuery("nextToken").String(*v.NextToken) 2859 } 2860 2861 if v.OnlyAssociated != nil { 2862 encoder.SetQuery("onlyAssociated").String(*v.OnlyAssociated) 2863 } 2864 2865 return nil 2866} 2867 2868type awsRestjson1_serializeOpListOrganizationAdminAccounts struct { 2869} 2870 2871func (*awsRestjson1_serializeOpListOrganizationAdminAccounts) ID() string { 2872 return "OperationSerializer" 2873} 2874 2875func (m *awsRestjson1_serializeOpListOrganizationAdminAccounts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2876 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2877) { 2878 request, ok := in.Request.(*smithyhttp.Request) 2879 if !ok { 2880 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2881 } 2882 2883 input, ok := in.Parameters.(*ListOrganizationAdminAccountsInput) 2884 _ = input 2885 if !ok { 2886 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2887 } 2888 2889 opPath, opQuery := httpbinding.SplitURI("/admin") 2890 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2891 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2892 request.Method = "GET" 2893 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2894 if err != nil { 2895 return out, metadata, &smithy.SerializationError{Err: err} 2896 } 2897 2898 if err := awsRestjson1_serializeOpHttpBindingsListOrganizationAdminAccountsInput(input, restEncoder); err != nil { 2899 return out, metadata, &smithy.SerializationError{Err: err} 2900 } 2901 2902 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2903 return out, metadata, &smithy.SerializationError{Err: err} 2904 } 2905 in.Request = request 2906 2907 return next.HandleSerialize(ctx, in) 2908} 2909func awsRestjson1_serializeOpHttpBindingsListOrganizationAdminAccountsInput(v *ListOrganizationAdminAccountsInput, encoder *httpbinding.Encoder) error { 2910 if v == nil { 2911 return fmt.Errorf("unsupported serialization of nil %T", v) 2912 } 2913 2914 if v.MaxResults != 0 { 2915 encoder.SetQuery("maxResults").Integer(v.MaxResults) 2916 } 2917 2918 if v.NextToken != nil { 2919 encoder.SetQuery("nextToken").String(*v.NextToken) 2920 } 2921 2922 return nil 2923} 2924 2925type awsRestjson1_serializeOpListTagsForResource struct { 2926} 2927 2928func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 2929 return "OperationSerializer" 2930} 2931 2932func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2933 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2934) { 2935 request, ok := in.Request.(*smithyhttp.Request) 2936 if !ok { 2937 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2938 } 2939 2940 input, ok := in.Parameters.(*ListTagsForResourceInput) 2941 _ = input 2942 if !ok { 2943 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2944 } 2945 2946 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 2947 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2948 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2949 request.Method = "GET" 2950 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2951 if err != nil { 2952 return out, metadata, &smithy.SerializationError{Err: err} 2953 } 2954 2955 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 2956 return out, metadata, &smithy.SerializationError{Err: err} 2957 } 2958 2959 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2960 return out, metadata, &smithy.SerializationError{Err: err} 2961 } 2962 in.Request = request 2963 2964 return next.HandleSerialize(ctx, in) 2965} 2966func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 2967 if v == nil { 2968 return fmt.Errorf("unsupported serialization of nil %T", v) 2969 } 2970 2971 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 2972 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 2973 } 2974 if v.ResourceArn != nil { 2975 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 2976 return err 2977 } 2978 } 2979 2980 return nil 2981} 2982 2983type awsRestjson1_serializeOpPutClassificationExportConfiguration struct { 2984} 2985 2986func (*awsRestjson1_serializeOpPutClassificationExportConfiguration) ID() string { 2987 return "OperationSerializer" 2988} 2989 2990func (m *awsRestjson1_serializeOpPutClassificationExportConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2991 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2992) { 2993 request, ok := in.Request.(*smithyhttp.Request) 2994 if !ok { 2995 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2996 } 2997 2998 input, ok := in.Parameters.(*PutClassificationExportConfigurationInput) 2999 _ = input 3000 if !ok { 3001 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3002 } 3003 3004 opPath, opQuery := httpbinding.SplitURI("/classification-export-configuration") 3005 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3006 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3007 request.Method = "PUT" 3008 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3009 if err != nil { 3010 return out, metadata, &smithy.SerializationError{Err: err} 3011 } 3012 3013 restEncoder.SetHeader("Content-Type").String("application/json") 3014 3015 jsonEncoder := smithyjson.NewEncoder() 3016 if err := awsRestjson1_serializeOpDocumentPutClassificationExportConfigurationInput(input, jsonEncoder.Value); err != nil { 3017 return out, metadata, &smithy.SerializationError{Err: err} 3018 } 3019 3020 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3021 return out, metadata, &smithy.SerializationError{Err: err} 3022 } 3023 3024 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3025 return out, metadata, &smithy.SerializationError{Err: err} 3026 } 3027 in.Request = request 3028 3029 return next.HandleSerialize(ctx, in) 3030} 3031func awsRestjson1_serializeOpHttpBindingsPutClassificationExportConfigurationInput(v *PutClassificationExportConfigurationInput, encoder *httpbinding.Encoder) error { 3032 if v == nil { 3033 return fmt.Errorf("unsupported serialization of nil %T", v) 3034 } 3035 3036 return nil 3037} 3038 3039func awsRestjson1_serializeOpDocumentPutClassificationExportConfigurationInput(v *PutClassificationExportConfigurationInput, value smithyjson.Value) error { 3040 object := value.Object() 3041 defer object.Close() 3042 3043 if v.Configuration != nil { 3044 ok := object.Key("configuration") 3045 if err := awsRestjson1_serializeDocumentClassificationExportConfiguration(v.Configuration, ok); err != nil { 3046 return err 3047 } 3048 } 3049 3050 return nil 3051} 3052 3053type awsRestjson1_serializeOpPutFindingsPublicationConfiguration struct { 3054} 3055 3056func (*awsRestjson1_serializeOpPutFindingsPublicationConfiguration) ID() string { 3057 return "OperationSerializer" 3058} 3059 3060func (m *awsRestjson1_serializeOpPutFindingsPublicationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3061 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3062) { 3063 request, ok := in.Request.(*smithyhttp.Request) 3064 if !ok { 3065 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3066 } 3067 3068 input, ok := in.Parameters.(*PutFindingsPublicationConfigurationInput) 3069 _ = input 3070 if !ok { 3071 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3072 } 3073 3074 opPath, opQuery := httpbinding.SplitURI("/findings-publication-configuration") 3075 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3076 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3077 request.Method = "PUT" 3078 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3079 if err != nil { 3080 return out, metadata, &smithy.SerializationError{Err: err} 3081 } 3082 3083 restEncoder.SetHeader("Content-Type").String("application/json") 3084 3085 jsonEncoder := smithyjson.NewEncoder() 3086 if err := awsRestjson1_serializeOpDocumentPutFindingsPublicationConfigurationInput(input, jsonEncoder.Value); err != nil { 3087 return out, metadata, &smithy.SerializationError{Err: err} 3088 } 3089 3090 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3091 return out, metadata, &smithy.SerializationError{Err: err} 3092 } 3093 3094 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3095 return out, metadata, &smithy.SerializationError{Err: err} 3096 } 3097 in.Request = request 3098 3099 return next.HandleSerialize(ctx, in) 3100} 3101func awsRestjson1_serializeOpHttpBindingsPutFindingsPublicationConfigurationInput(v *PutFindingsPublicationConfigurationInput, encoder *httpbinding.Encoder) error { 3102 if v == nil { 3103 return fmt.Errorf("unsupported serialization of nil %T", v) 3104 } 3105 3106 return nil 3107} 3108 3109func awsRestjson1_serializeOpDocumentPutFindingsPublicationConfigurationInput(v *PutFindingsPublicationConfigurationInput, value smithyjson.Value) error { 3110 object := value.Object() 3111 defer object.Close() 3112 3113 if v.ClientToken != nil { 3114 ok := object.Key("clientToken") 3115 ok.String(*v.ClientToken) 3116 } 3117 3118 if v.SecurityHubConfiguration != nil { 3119 ok := object.Key("securityHubConfiguration") 3120 if err := awsRestjson1_serializeDocumentSecurityHubConfiguration(v.SecurityHubConfiguration, ok); err != nil { 3121 return err 3122 } 3123 } 3124 3125 return nil 3126} 3127 3128type awsRestjson1_serializeOpTagResource struct { 3129} 3130 3131func (*awsRestjson1_serializeOpTagResource) ID() string { 3132 return "OperationSerializer" 3133} 3134 3135func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3136 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3137) { 3138 request, ok := in.Request.(*smithyhttp.Request) 3139 if !ok { 3140 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3141 } 3142 3143 input, ok := in.Parameters.(*TagResourceInput) 3144 _ = input 3145 if !ok { 3146 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3147 } 3148 3149 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 3150 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3151 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3152 request.Method = "POST" 3153 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3154 if err != nil { 3155 return out, metadata, &smithy.SerializationError{Err: err} 3156 } 3157 3158 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 3159 return out, metadata, &smithy.SerializationError{Err: err} 3160 } 3161 3162 restEncoder.SetHeader("Content-Type").String("application/json") 3163 3164 jsonEncoder := smithyjson.NewEncoder() 3165 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 3166 return out, metadata, &smithy.SerializationError{Err: err} 3167 } 3168 3169 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3170 return out, metadata, &smithy.SerializationError{Err: err} 3171 } 3172 3173 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3174 return out, metadata, &smithy.SerializationError{Err: err} 3175 } 3176 in.Request = request 3177 3178 return next.HandleSerialize(ctx, in) 3179} 3180func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 3181 if v == nil { 3182 return fmt.Errorf("unsupported serialization of nil %T", v) 3183 } 3184 3185 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 3186 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 3187 } 3188 if v.ResourceArn != nil { 3189 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 3190 return err 3191 } 3192 } 3193 3194 return nil 3195} 3196 3197func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 3198 object := value.Object() 3199 defer object.Close() 3200 3201 if v.Tags != nil { 3202 ok := object.Key("tags") 3203 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 3204 return err 3205 } 3206 } 3207 3208 return nil 3209} 3210 3211type awsRestjson1_serializeOpTestCustomDataIdentifier struct { 3212} 3213 3214func (*awsRestjson1_serializeOpTestCustomDataIdentifier) ID() string { 3215 return "OperationSerializer" 3216} 3217 3218func (m *awsRestjson1_serializeOpTestCustomDataIdentifier) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3219 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3220) { 3221 request, ok := in.Request.(*smithyhttp.Request) 3222 if !ok { 3223 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3224 } 3225 3226 input, ok := in.Parameters.(*TestCustomDataIdentifierInput) 3227 _ = input 3228 if !ok { 3229 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3230 } 3231 3232 opPath, opQuery := httpbinding.SplitURI("/custom-data-identifiers/test") 3233 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3234 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3235 request.Method = "POST" 3236 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3237 if err != nil { 3238 return out, metadata, &smithy.SerializationError{Err: err} 3239 } 3240 3241 restEncoder.SetHeader("Content-Type").String("application/json") 3242 3243 jsonEncoder := smithyjson.NewEncoder() 3244 if err := awsRestjson1_serializeOpDocumentTestCustomDataIdentifierInput(input, jsonEncoder.Value); err != nil { 3245 return out, metadata, &smithy.SerializationError{Err: err} 3246 } 3247 3248 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3249 return out, metadata, &smithy.SerializationError{Err: err} 3250 } 3251 3252 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3253 return out, metadata, &smithy.SerializationError{Err: err} 3254 } 3255 in.Request = request 3256 3257 return next.HandleSerialize(ctx, in) 3258} 3259func awsRestjson1_serializeOpHttpBindingsTestCustomDataIdentifierInput(v *TestCustomDataIdentifierInput, encoder *httpbinding.Encoder) error { 3260 if v == nil { 3261 return fmt.Errorf("unsupported serialization of nil %T", v) 3262 } 3263 3264 return nil 3265} 3266 3267func awsRestjson1_serializeOpDocumentTestCustomDataIdentifierInput(v *TestCustomDataIdentifierInput, value smithyjson.Value) error { 3268 object := value.Object() 3269 defer object.Close() 3270 3271 if v.IgnoreWords != nil { 3272 ok := object.Key("ignoreWords") 3273 if err := awsRestjson1_serializeDocument__listOf__string(v.IgnoreWords, ok); err != nil { 3274 return err 3275 } 3276 } 3277 3278 if v.Keywords != nil { 3279 ok := object.Key("keywords") 3280 if err := awsRestjson1_serializeDocument__listOf__string(v.Keywords, ok); err != nil { 3281 return err 3282 } 3283 } 3284 3285 if v.MaximumMatchDistance != 0 { 3286 ok := object.Key("maximumMatchDistance") 3287 ok.Integer(v.MaximumMatchDistance) 3288 } 3289 3290 if v.Regex != nil { 3291 ok := object.Key("regex") 3292 ok.String(*v.Regex) 3293 } 3294 3295 if v.SampleText != nil { 3296 ok := object.Key("sampleText") 3297 ok.String(*v.SampleText) 3298 } 3299 3300 return nil 3301} 3302 3303type awsRestjson1_serializeOpUntagResource struct { 3304} 3305 3306func (*awsRestjson1_serializeOpUntagResource) ID() string { 3307 return "OperationSerializer" 3308} 3309 3310func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3311 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3312) { 3313 request, ok := in.Request.(*smithyhttp.Request) 3314 if !ok { 3315 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3316 } 3317 3318 input, ok := in.Parameters.(*UntagResourceInput) 3319 _ = input 3320 if !ok { 3321 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3322 } 3323 3324 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 3325 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3326 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3327 request.Method = "DELETE" 3328 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3329 if err != nil { 3330 return out, metadata, &smithy.SerializationError{Err: err} 3331 } 3332 3333 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 3334 return out, metadata, &smithy.SerializationError{Err: err} 3335 } 3336 3337 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3338 return out, metadata, &smithy.SerializationError{Err: err} 3339 } 3340 in.Request = request 3341 3342 return next.HandleSerialize(ctx, in) 3343} 3344func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 3345 if v == nil { 3346 return fmt.Errorf("unsupported serialization of nil %T", v) 3347 } 3348 3349 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 3350 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 3351 } 3352 if v.ResourceArn != nil { 3353 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 3354 return err 3355 } 3356 } 3357 3358 if v.TagKeys != nil { 3359 for i := range v.TagKeys { 3360 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 3361 } 3362 } 3363 3364 return nil 3365} 3366 3367type awsRestjson1_serializeOpUpdateClassificationJob struct { 3368} 3369 3370func (*awsRestjson1_serializeOpUpdateClassificationJob) ID() string { 3371 return "OperationSerializer" 3372} 3373 3374func (m *awsRestjson1_serializeOpUpdateClassificationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3375 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3376) { 3377 request, ok := in.Request.(*smithyhttp.Request) 3378 if !ok { 3379 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3380 } 3381 3382 input, ok := in.Parameters.(*UpdateClassificationJobInput) 3383 _ = input 3384 if !ok { 3385 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3386 } 3387 3388 opPath, opQuery := httpbinding.SplitURI("/jobs/{jobId}") 3389 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3390 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3391 request.Method = "PATCH" 3392 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3393 if err != nil { 3394 return out, metadata, &smithy.SerializationError{Err: err} 3395 } 3396 3397 if err := awsRestjson1_serializeOpHttpBindingsUpdateClassificationJobInput(input, restEncoder); err != nil { 3398 return out, metadata, &smithy.SerializationError{Err: err} 3399 } 3400 3401 restEncoder.SetHeader("Content-Type").String("application/json") 3402 3403 jsonEncoder := smithyjson.NewEncoder() 3404 if err := awsRestjson1_serializeOpDocumentUpdateClassificationJobInput(input, jsonEncoder.Value); err != nil { 3405 return out, metadata, &smithy.SerializationError{Err: err} 3406 } 3407 3408 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3409 return out, metadata, &smithy.SerializationError{Err: err} 3410 } 3411 3412 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3413 return out, metadata, &smithy.SerializationError{Err: err} 3414 } 3415 in.Request = request 3416 3417 return next.HandleSerialize(ctx, in) 3418} 3419func awsRestjson1_serializeOpHttpBindingsUpdateClassificationJobInput(v *UpdateClassificationJobInput, encoder *httpbinding.Encoder) error { 3420 if v == nil { 3421 return fmt.Errorf("unsupported serialization of nil %T", v) 3422 } 3423 3424 if v.JobId == nil || len(*v.JobId) == 0 { 3425 return &smithy.SerializationError{Err: fmt.Errorf("input member jobId must not be empty")} 3426 } 3427 if v.JobId != nil { 3428 if err := encoder.SetURI("jobId").String(*v.JobId); err != nil { 3429 return err 3430 } 3431 } 3432 3433 return nil 3434} 3435 3436func awsRestjson1_serializeOpDocumentUpdateClassificationJobInput(v *UpdateClassificationJobInput, value smithyjson.Value) error { 3437 object := value.Object() 3438 defer object.Close() 3439 3440 if len(v.JobStatus) > 0 { 3441 ok := object.Key("jobStatus") 3442 ok.String(string(v.JobStatus)) 3443 } 3444 3445 return nil 3446} 3447 3448type awsRestjson1_serializeOpUpdateFindingsFilter struct { 3449} 3450 3451func (*awsRestjson1_serializeOpUpdateFindingsFilter) ID() string { 3452 return "OperationSerializer" 3453} 3454 3455func (m *awsRestjson1_serializeOpUpdateFindingsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3456 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3457) { 3458 request, ok := in.Request.(*smithyhttp.Request) 3459 if !ok { 3460 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3461 } 3462 3463 input, ok := in.Parameters.(*UpdateFindingsFilterInput) 3464 _ = input 3465 if !ok { 3466 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3467 } 3468 3469 opPath, opQuery := httpbinding.SplitURI("/findingsfilters/{id}") 3470 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3471 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3472 request.Method = "PATCH" 3473 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3474 if err != nil { 3475 return out, metadata, &smithy.SerializationError{Err: err} 3476 } 3477 3478 if err := awsRestjson1_serializeOpHttpBindingsUpdateFindingsFilterInput(input, restEncoder); err != nil { 3479 return out, metadata, &smithy.SerializationError{Err: err} 3480 } 3481 3482 restEncoder.SetHeader("Content-Type").String("application/json") 3483 3484 jsonEncoder := smithyjson.NewEncoder() 3485 if err := awsRestjson1_serializeOpDocumentUpdateFindingsFilterInput(input, jsonEncoder.Value); err != nil { 3486 return out, metadata, &smithy.SerializationError{Err: err} 3487 } 3488 3489 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3490 return out, metadata, &smithy.SerializationError{Err: err} 3491 } 3492 3493 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3494 return out, metadata, &smithy.SerializationError{Err: err} 3495 } 3496 in.Request = request 3497 3498 return next.HandleSerialize(ctx, in) 3499} 3500func awsRestjson1_serializeOpHttpBindingsUpdateFindingsFilterInput(v *UpdateFindingsFilterInput, encoder *httpbinding.Encoder) error { 3501 if v == nil { 3502 return fmt.Errorf("unsupported serialization of nil %T", v) 3503 } 3504 3505 if v.Id == nil || len(*v.Id) == 0 { 3506 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 3507 } 3508 if v.Id != nil { 3509 if err := encoder.SetURI("id").String(*v.Id); err != nil { 3510 return err 3511 } 3512 } 3513 3514 return nil 3515} 3516 3517func awsRestjson1_serializeOpDocumentUpdateFindingsFilterInput(v *UpdateFindingsFilterInput, value smithyjson.Value) error { 3518 object := value.Object() 3519 defer object.Close() 3520 3521 if len(v.Action) > 0 { 3522 ok := object.Key("action") 3523 ok.String(string(v.Action)) 3524 } 3525 3526 if v.Description != nil { 3527 ok := object.Key("description") 3528 ok.String(*v.Description) 3529 } 3530 3531 if v.FindingCriteria != nil { 3532 ok := object.Key("findingCriteria") 3533 if err := awsRestjson1_serializeDocumentFindingCriteria(v.FindingCriteria, ok); err != nil { 3534 return err 3535 } 3536 } 3537 3538 if v.Name != nil { 3539 ok := object.Key("name") 3540 ok.String(*v.Name) 3541 } 3542 3543 if v.Position != 0 { 3544 ok := object.Key("position") 3545 ok.Integer(v.Position) 3546 } 3547 3548 return nil 3549} 3550 3551type awsRestjson1_serializeOpUpdateMacieSession struct { 3552} 3553 3554func (*awsRestjson1_serializeOpUpdateMacieSession) ID() string { 3555 return "OperationSerializer" 3556} 3557 3558func (m *awsRestjson1_serializeOpUpdateMacieSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3559 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3560) { 3561 request, ok := in.Request.(*smithyhttp.Request) 3562 if !ok { 3563 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3564 } 3565 3566 input, ok := in.Parameters.(*UpdateMacieSessionInput) 3567 _ = input 3568 if !ok { 3569 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3570 } 3571 3572 opPath, opQuery := httpbinding.SplitURI("/macie") 3573 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3574 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3575 request.Method = "PATCH" 3576 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3577 if err != nil { 3578 return out, metadata, &smithy.SerializationError{Err: err} 3579 } 3580 3581 restEncoder.SetHeader("Content-Type").String("application/json") 3582 3583 jsonEncoder := smithyjson.NewEncoder() 3584 if err := awsRestjson1_serializeOpDocumentUpdateMacieSessionInput(input, jsonEncoder.Value); err != nil { 3585 return out, metadata, &smithy.SerializationError{Err: err} 3586 } 3587 3588 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3589 return out, metadata, &smithy.SerializationError{Err: err} 3590 } 3591 3592 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3593 return out, metadata, &smithy.SerializationError{Err: err} 3594 } 3595 in.Request = request 3596 3597 return next.HandleSerialize(ctx, in) 3598} 3599func awsRestjson1_serializeOpHttpBindingsUpdateMacieSessionInput(v *UpdateMacieSessionInput, encoder *httpbinding.Encoder) error { 3600 if v == nil { 3601 return fmt.Errorf("unsupported serialization of nil %T", v) 3602 } 3603 3604 return nil 3605} 3606 3607func awsRestjson1_serializeOpDocumentUpdateMacieSessionInput(v *UpdateMacieSessionInput, value smithyjson.Value) error { 3608 object := value.Object() 3609 defer object.Close() 3610 3611 if len(v.FindingPublishingFrequency) > 0 { 3612 ok := object.Key("findingPublishingFrequency") 3613 ok.String(string(v.FindingPublishingFrequency)) 3614 } 3615 3616 if len(v.Status) > 0 { 3617 ok := object.Key("status") 3618 ok.String(string(v.Status)) 3619 } 3620 3621 return nil 3622} 3623 3624type awsRestjson1_serializeOpUpdateMemberSession struct { 3625} 3626 3627func (*awsRestjson1_serializeOpUpdateMemberSession) ID() string { 3628 return "OperationSerializer" 3629} 3630 3631func (m *awsRestjson1_serializeOpUpdateMemberSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3632 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3633) { 3634 request, ok := in.Request.(*smithyhttp.Request) 3635 if !ok { 3636 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3637 } 3638 3639 input, ok := in.Parameters.(*UpdateMemberSessionInput) 3640 _ = input 3641 if !ok { 3642 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3643 } 3644 3645 opPath, opQuery := httpbinding.SplitURI("/macie/members/{id}") 3646 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3647 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3648 request.Method = "PATCH" 3649 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3650 if err != nil { 3651 return out, metadata, &smithy.SerializationError{Err: err} 3652 } 3653 3654 if err := awsRestjson1_serializeOpHttpBindingsUpdateMemberSessionInput(input, restEncoder); err != nil { 3655 return out, metadata, &smithy.SerializationError{Err: err} 3656 } 3657 3658 restEncoder.SetHeader("Content-Type").String("application/json") 3659 3660 jsonEncoder := smithyjson.NewEncoder() 3661 if err := awsRestjson1_serializeOpDocumentUpdateMemberSessionInput(input, jsonEncoder.Value); err != nil { 3662 return out, metadata, &smithy.SerializationError{Err: err} 3663 } 3664 3665 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3666 return out, metadata, &smithy.SerializationError{Err: err} 3667 } 3668 3669 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3670 return out, metadata, &smithy.SerializationError{Err: err} 3671 } 3672 in.Request = request 3673 3674 return next.HandleSerialize(ctx, in) 3675} 3676func awsRestjson1_serializeOpHttpBindingsUpdateMemberSessionInput(v *UpdateMemberSessionInput, encoder *httpbinding.Encoder) error { 3677 if v == nil { 3678 return fmt.Errorf("unsupported serialization of nil %T", v) 3679 } 3680 3681 if v.Id == nil || len(*v.Id) == 0 { 3682 return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")} 3683 } 3684 if v.Id != nil { 3685 if err := encoder.SetURI("id").String(*v.Id); err != nil { 3686 return err 3687 } 3688 } 3689 3690 return nil 3691} 3692 3693func awsRestjson1_serializeOpDocumentUpdateMemberSessionInput(v *UpdateMemberSessionInput, value smithyjson.Value) error { 3694 object := value.Object() 3695 defer object.Close() 3696 3697 if len(v.Status) > 0 { 3698 ok := object.Key("status") 3699 ok.String(string(v.Status)) 3700 } 3701 3702 return nil 3703} 3704 3705type awsRestjson1_serializeOpUpdateOrganizationConfiguration struct { 3706} 3707 3708func (*awsRestjson1_serializeOpUpdateOrganizationConfiguration) ID() string { 3709 return "OperationSerializer" 3710} 3711 3712func (m *awsRestjson1_serializeOpUpdateOrganizationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3713 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3714) { 3715 request, ok := in.Request.(*smithyhttp.Request) 3716 if !ok { 3717 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3718 } 3719 3720 input, ok := in.Parameters.(*UpdateOrganizationConfigurationInput) 3721 _ = input 3722 if !ok { 3723 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3724 } 3725 3726 opPath, opQuery := httpbinding.SplitURI("/admin/configuration") 3727 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3728 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3729 request.Method = "PATCH" 3730 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3731 if err != nil { 3732 return out, metadata, &smithy.SerializationError{Err: err} 3733 } 3734 3735 restEncoder.SetHeader("Content-Type").String("application/json") 3736 3737 jsonEncoder := smithyjson.NewEncoder() 3738 if err := awsRestjson1_serializeOpDocumentUpdateOrganizationConfigurationInput(input, jsonEncoder.Value); err != nil { 3739 return out, metadata, &smithy.SerializationError{Err: err} 3740 } 3741 3742 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3743 return out, metadata, &smithy.SerializationError{Err: err} 3744 } 3745 3746 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3747 return out, metadata, &smithy.SerializationError{Err: err} 3748 } 3749 in.Request = request 3750 3751 return next.HandleSerialize(ctx, in) 3752} 3753func awsRestjson1_serializeOpHttpBindingsUpdateOrganizationConfigurationInput(v *UpdateOrganizationConfigurationInput, encoder *httpbinding.Encoder) error { 3754 if v == nil { 3755 return fmt.Errorf("unsupported serialization of nil %T", v) 3756 } 3757 3758 return nil 3759} 3760 3761func awsRestjson1_serializeOpDocumentUpdateOrganizationConfigurationInput(v *UpdateOrganizationConfigurationInput, value smithyjson.Value) error { 3762 object := value.Object() 3763 defer object.Close() 3764 3765 { 3766 ok := object.Key("autoEnable") 3767 ok.Boolean(v.AutoEnable) 3768 } 3769 3770 return nil 3771} 3772 3773func awsRestjson1_serializeDocument__listOf__string(v []string, value smithyjson.Value) error { 3774 array := value.Array() 3775 defer array.Close() 3776 3777 for i := range v { 3778 av := array.Value() 3779 av.String(v[i]) 3780 } 3781 return nil 3782} 3783 3784func awsRestjson1_serializeDocument__listOfFindingType(v []types.FindingType, value smithyjson.Value) error { 3785 array := value.Array() 3786 defer array.Close() 3787 3788 for i := range v { 3789 av := array.Value() 3790 av.String(string(v[i])) 3791 } 3792 return nil 3793} 3794 3795func awsRestjson1_serializeDocument__listOfJobScopeTerm(v []types.JobScopeTerm, value smithyjson.Value) error { 3796 array := value.Array() 3797 defer array.Close() 3798 3799 for i := range v { 3800 av := array.Value() 3801 if err := awsRestjson1_serializeDocumentJobScopeTerm(&v[i], av); err != nil { 3802 return err 3803 } 3804 } 3805 return nil 3806} 3807 3808func awsRestjson1_serializeDocument__listOfListJobsFilterTerm(v []types.ListJobsFilterTerm, value smithyjson.Value) error { 3809 array := value.Array() 3810 defer array.Close() 3811 3812 for i := range v { 3813 av := array.Value() 3814 if err := awsRestjson1_serializeDocumentListJobsFilterTerm(&v[i], av); err != nil { 3815 return err 3816 } 3817 } 3818 return nil 3819} 3820 3821func awsRestjson1_serializeDocument__listOfS3BucketDefinitionForJob(v []types.S3BucketDefinitionForJob, value smithyjson.Value) error { 3822 array := value.Array() 3823 defer array.Close() 3824 3825 for i := range v { 3826 av := array.Value() 3827 if err := awsRestjson1_serializeDocumentS3BucketDefinitionForJob(&v[i], av); err != nil { 3828 return err 3829 } 3830 } 3831 return nil 3832} 3833 3834func awsRestjson1_serializeDocument__listOfTagValuePair(v []types.TagValuePair, value smithyjson.Value) error { 3835 array := value.Array() 3836 defer array.Close() 3837 3838 for i := range v { 3839 av := array.Value() 3840 if err := awsRestjson1_serializeDocumentTagValuePair(&v[i], av); err != nil { 3841 return err 3842 } 3843 } 3844 return nil 3845} 3846 3847func awsRestjson1_serializeDocument__listOfUsageStatisticsFilter(v []types.UsageStatisticsFilter, value smithyjson.Value) error { 3848 array := value.Array() 3849 defer array.Close() 3850 3851 for i := range v { 3852 av := array.Value() 3853 if err := awsRestjson1_serializeDocumentUsageStatisticsFilter(&v[i], av); err != nil { 3854 return err 3855 } 3856 } 3857 return nil 3858} 3859 3860func awsRestjson1_serializeDocumentAccountDetail(v *types.AccountDetail, value smithyjson.Value) error { 3861 object := value.Object() 3862 defer object.Close() 3863 3864 if v.AccountId != nil { 3865 ok := object.Key("accountId") 3866 ok.String(*v.AccountId) 3867 } 3868 3869 if v.Email != nil { 3870 ok := object.Key("email") 3871 ok.String(*v.Email) 3872 } 3873 3874 return nil 3875} 3876 3877func awsRestjson1_serializeDocumentBucketCriteria(v map[string]types.BucketCriteriaAdditionalProperties, value smithyjson.Value) error { 3878 object := value.Object() 3879 defer object.Close() 3880 3881 for key := range v { 3882 om := object.Key(key) 3883 mapVar := v[key] 3884 if err := awsRestjson1_serializeDocumentBucketCriteriaAdditionalProperties(&mapVar, om); err != nil { 3885 return err 3886 } 3887 } 3888 return nil 3889} 3890 3891func awsRestjson1_serializeDocumentBucketCriteriaAdditionalProperties(v *types.BucketCriteriaAdditionalProperties, value smithyjson.Value) error { 3892 object := value.Object() 3893 defer object.Close() 3894 3895 if v.Eq != nil { 3896 ok := object.Key("eq") 3897 if err := awsRestjson1_serializeDocument__listOf__string(v.Eq, ok); err != nil { 3898 return err 3899 } 3900 } 3901 3902 if v.Gt != 0 { 3903 ok := object.Key("gt") 3904 ok.Long(v.Gt) 3905 } 3906 3907 if v.Gte != 0 { 3908 ok := object.Key("gte") 3909 ok.Long(v.Gte) 3910 } 3911 3912 if v.Lt != 0 { 3913 ok := object.Key("lt") 3914 ok.Long(v.Lt) 3915 } 3916 3917 if v.Lte != 0 { 3918 ok := object.Key("lte") 3919 ok.Long(v.Lte) 3920 } 3921 3922 if v.Neq != nil { 3923 ok := object.Key("neq") 3924 if err := awsRestjson1_serializeDocument__listOf__string(v.Neq, ok); err != nil { 3925 return err 3926 } 3927 } 3928 3929 if v.Prefix != nil { 3930 ok := object.Key("prefix") 3931 ok.String(*v.Prefix) 3932 } 3933 3934 return nil 3935} 3936 3937func awsRestjson1_serializeDocumentBucketSortCriteria(v *types.BucketSortCriteria, value smithyjson.Value) error { 3938 object := value.Object() 3939 defer object.Close() 3940 3941 if v.AttributeName != nil { 3942 ok := object.Key("attributeName") 3943 ok.String(*v.AttributeName) 3944 } 3945 3946 if len(v.OrderBy) > 0 { 3947 ok := object.Key("orderBy") 3948 ok.String(string(v.OrderBy)) 3949 } 3950 3951 return nil 3952} 3953 3954func awsRestjson1_serializeDocumentClassificationExportConfiguration(v *types.ClassificationExportConfiguration, value smithyjson.Value) error { 3955 object := value.Object() 3956 defer object.Close() 3957 3958 if v.S3Destination != nil { 3959 ok := object.Key("s3Destination") 3960 if err := awsRestjson1_serializeDocumentS3Destination(v.S3Destination, ok); err != nil { 3961 return err 3962 } 3963 } 3964 3965 return nil 3966} 3967 3968func awsRestjson1_serializeDocumentCriterion(v map[string]types.CriterionAdditionalProperties, value smithyjson.Value) error { 3969 object := value.Object() 3970 defer object.Close() 3971 3972 for key := range v { 3973 om := object.Key(key) 3974 mapVar := v[key] 3975 if err := awsRestjson1_serializeDocumentCriterionAdditionalProperties(&mapVar, om); err != nil { 3976 return err 3977 } 3978 } 3979 return nil 3980} 3981 3982func awsRestjson1_serializeDocumentCriterionAdditionalProperties(v *types.CriterionAdditionalProperties, value smithyjson.Value) error { 3983 object := value.Object() 3984 defer object.Close() 3985 3986 if v.Eq != nil { 3987 ok := object.Key("eq") 3988 if err := awsRestjson1_serializeDocument__listOf__string(v.Eq, ok); err != nil { 3989 return err 3990 } 3991 } 3992 3993 if v.EqExactMatch != nil { 3994 ok := object.Key("eqExactMatch") 3995 if err := awsRestjson1_serializeDocument__listOf__string(v.EqExactMatch, ok); err != nil { 3996 return err 3997 } 3998 } 3999 4000 if v.Gt != 0 { 4001 ok := object.Key("gt") 4002 ok.Long(v.Gt) 4003 } 4004 4005 if v.Gte != 0 { 4006 ok := object.Key("gte") 4007 ok.Long(v.Gte) 4008 } 4009 4010 if v.Lt != 0 { 4011 ok := object.Key("lt") 4012 ok.Long(v.Lt) 4013 } 4014 4015 if v.Lte != 0 { 4016 ok := object.Key("lte") 4017 ok.Long(v.Lte) 4018 } 4019 4020 if v.Neq != nil { 4021 ok := object.Key("neq") 4022 if err := awsRestjson1_serializeDocument__listOf__string(v.Neq, ok); err != nil { 4023 return err 4024 } 4025 } 4026 4027 return nil 4028} 4029 4030func awsRestjson1_serializeDocumentDailySchedule(v *types.DailySchedule, value smithyjson.Value) error { 4031 object := value.Object() 4032 defer object.Close() 4033 4034 return nil 4035} 4036 4037func awsRestjson1_serializeDocumentFindingCriteria(v *types.FindingCriteria, value smithyjson.Value) error { 4038 object := value.Object() 4039 defer object.Close() 4040 4041 if v.Criterion != nil { 4042 ok := object.Key("criterion") 4043 if err := awsRestjson1_serializeDocumentCriterion(v.Criterion, ok); err != nil { 4044 return err 4045 } 4046 } 4047 4048 return nil 4049} 4050 4051func awsRestjson1_serializeDocumentFindingStatisticsSortCriteria(v *types.FindingStatisticsSortCriteria, value smithyjson.Value) error { 4052 object := value.Object() 4053 defer object.Close() 4054 4055 if len(v.AttributeName) > 0 { 4056 ok := object.Key("attributeName") 4057 ok.String(string(v.AttributeName)) 4058 } 4059 4060 if len(v.OrderBy) > 0 { 4061 ok := object.Key("orderBy") 4062 ok.String(string(v.OrderBy)) 4063 } 4064 4065 return nil 4066} 4067 4068func awsRestjson1_serializeDocumentJobScheduleFrequency(v *types.JobScheduleFrequency, value smithyjson.Value) error { 4069 object := value.Object() 4070 defer object.Close() 4071 4072 if v.DailySchedule != nil { 4073 ok := object.Key("dailySchedule") 4074 if err := awsRestjson1_serializeDocumentDailySchedule(v.DailySchedule, ok); err != nil { 4075 return err 4076 } 4077 } 4078 4079 if v.MonthlySchedule != nil { 4080 ok := object.Key("monthlySchedule") 4081 if err := awsRestjson1_serializeDocumentMonthlySchedule(v.MonthlySchedule, ok); err != nil { 4082 return err 4083 } 4084 } 4085 4086 if v.WeeklySchedule != nil { 4087 ok := object.Key("weeklySchedule") 4088 if err := awsRestjson1_serializeDocumentWeeklySchedule(v.WeeklySchedule, ok); err != nil { 4089 return err 4090 } 4091 } 4092 4093 return nil 4094} 4095 4096func awsRestjson1_serializeDocumentJobScopeTerm(v *types.JobScopeTerm, value smithyjson.Value) error { 4097 object := value.Object() 4098 defer object.Close() 4099 4100 if v.SimpleScopeTerm != nil { 4101 ok := object.Key("simpleScopeTerm") 4102 if err := awsRestjson1_serializeDocumentSimpleScopeTerm(v.SimpleScopeTerm, ok); err != nil { 4103 return err 4104 } 4105 } 4106 4107 if v.TagScopeTerm != nil { 4108 ok := object.Key("tagScopeTerm") 4109 if err := awsRestjson1_serializeDocumentTagScopeTerm(v.TagScopeTerm, ok); err != nil { 4110 return err 4111 } 4112 } 4113 4114 return nil 4115} 4116 4117func awsRestjson1_serializeDocumentJobScopingBlock(v *types.JobScopingBlock, value smithyjson.Value) error { 4118 object := value.Object() 4119 defer object.Close() 4120 4121 if v.And != nil { 4122 ok := object.Key("and") 4123 if err := awsRestjson1_serializeDocument__listOfJobScopeTerm(v.And, ok); err != nil { 4124 return err 4125 } 4126 } 4127 4128 return nil 4129} 4130 4131func awsRestjson1_serializeDocumentListJobsFilterCriteria(v *types.ListJobsFilterCriteria, value smithyjson.Value) error { 4132 object := value.Object() 4133 defer object.Close() 4134 4135 if v.Excludes != nil { 4136 ok := object.Key("excludes") 4137 if err := awsRestjson1_serializeDocument__listOfListJobsFilterTerm(v.Excludes, ok); err != nil { 4138 return err 4139 } 4140 } 4141 4142 if v.Includes != nil { 4143 ok := object.Key("includes") 4144 if err := awsRestjson1_serializeDocument__listOfListJobsFilterTerm(v.Includes, ok); err != nil { 4145 return err 4146 } 4147 } 4148 4149 return nil 4150} 4151 4152func awsRestjson1_serializeDocumentListJobsFilterTerm(v *types.ListJobsFilterTerm, value smithyjson.Value) error { 4153 object := value.Object() 4154 defer object.Close() 4155 4156 if len(v.Comparator) > 0 { 4157 ok := object.Key("comparator") 4158 ok.String(string(v.Comparator)) 4159 } 4160 4161 if len(v.Key) > 0 { 4162 ok := object.Key("key") 4163 ok.String(string(v.Key)) 4164 } 4165 4166 if v.Values != nil { 4167 ok := object.Key("values") 4168 if err := awsRestjson1_serializeDocument__listOf__string(v.Values, ok); err != nil { 4169 return err 4170 } 4171 } 4172 4173 return nil 4174} 4175 4176func awsRestjson1_serializeDocumentListJobsSortCriteria(v *types.ListJobsSortCriteria, value smithyjson.Value) error { 4177 object := value.Object() 4178 defer object.Close() 4179 4180 if len(v.AttributeName) > 0 { 4181 ok := object.Key("attributeName") 4182 ok.String(string(v.AttributeName)) 4183 } 4184 4185 if len(v.OrderBy) > 0 { 4186 ok := object.Key("orderBy") 4187 ok.String(string(v.OrderBy)) 4188 } 4189 4190 return nil 4191} 4192 4193func awsRestjson1_serializeDocumentMonthlySchedule(v *types.MonthlySchedule, value smithyjson.Value) error { 4194 object := value.Object() 4195 defer object.Close() 4196 4197 if v.DayOfMonth != 0 { 4198 ok := object.Key("dayOfMonth") 4199 ok.Integer(v.DayOfMonth) 4200 } 4201 4202 return nil 4203} 4204 4205func awsRestjson1_serializeDocumentS3BucketDefinitionForJob(v *types.S3BucketDefinitionForJob, value smithyjson.Value) error { 4206 object := value.Object() 4207 defer object.Close() 4208 4209 if v.AccountId != nil { 4210 ok := object.Key("accountId") 4211 ok.String(*v.AccountId) 4212 } 4213 4214 if v.Buckets != nil { 4215 ok := object.Key("buckets") 4216 if err := awsRestjson1_serializeDocument__listOf__string(v.Buckets, ok); err != nil { 4217 return err 4218 } 4219 } 4220 4221 return nil 4222} 4223 4224func awsRestjson1_serializeDocumentS3Destination(v *types.S3Destination, value smithyjson.Value) error { 4225 object := value.Object() 4226 defer object.Close() 4227 4228 if v.BucketName != nil { 4229 ok := object.Key("bucketName") 4230 ok.String(*v.BucketName) 4231 } 4232 4233 if v.KeyPrefix != nil { 4234 ok := object.Key("keyPrefix") 4235 ok.String(*v.KeyPrefix) 4236 } 4237 4238 if v.KmsKeyArn != nil { 4239 ok := object.Key("kmsKeyArn") 4240 ok.String(*v.KmsKeyArn) 4241 } 4242 4243 return nil 4244} 4245 4246func awsRestjson1_serializeDocumentS3JobDefinition(v *types.S3JobDefinition, value smithyjson.Value) error { 4247 object := value.Object() 4248 defer object.Close() 4249 4250 if v.BucketDefinitions != nil { 4251 ok := object.Key("bucketDefinitions") 4252 if err := awsRestjson1_serializeDocument__listOfS3BucketDefinitionForJob(v.BucketDefinitions, ok); err != nil { 4253 return err 4254 } 4255 } 4256 4257 if v.Scoping != nil { 4258 ok := object.Key("scoping") 4259 if err := awsRestjson1_serializeDocumentScoping(v.Scoping, ok); err != nil { 4260 return err 4261 } 4262 } 4263 4264 return nil 4265} 4266 4267func awsRestjson1_serializeDocumentScoping(v *types.Scoping, value smithyjson.Value) error { 4268 object := value.Object() 4269 defer object.Close() 4270 4271 if v.Excludes != nil { 4272 ok := object.Key("excludes") 4273 if err := awsRestjson1_serializeDocumentJobScopingBlock(v.Excludes, ok); err != nil { 4274 return err 4275 } 4276 } 4277 4278 if v.Includes != nil { 4279 ok := object.Key("includes") 4280 if err := awsRestjson1_serializeDocumentJobScopingBlock(v.Includes, ok); err != nil { 4281 return err 4282 } 4283 } 4284 4285 return nil 4286} 4287 4288func awsRestjson1_serializeDocumentSecurityHubConfiguration(v *types.SecurityHubConfiguration, value smithyjson.Value) error { 4289 object := value.Object() 4290 defer object.Close() 4291 4292 { 4293 ok := object.Key("publishClassificationFindings") 4294 ok.Boolean(v.PublishClassificationFindings) 4295 } 4296 4297 { 4298 ok := object.Key("publishPolicyFindings") 4299 ok.Boolean(v.PublishPolicyFindings) 4300 } 4301 4302 return nil 4303} 4304 4305func awsRestjson1_serializeDocumentSimpleScopeTerm(v *types.SimpleScopeTerm, value smithyjson.Value) error { 4306 object := value.Object() 4307 defer object.Close() 4308 4309 if len(v.Comparator) > 0 { 4310 ok := object.Key("comparator") 4311 ok.String(string(v.Comparator)) 4312 } 4313 4314 if len(v.Key) > 0 { 4315 ok := object.Key("key") 4316 ok.String(string(v.Key)) 4317 } 4318 4319 if v.Values != nil { 4320 ok := object.Key("values") 4321 if err := awsRestjson1_serializeDocument__listOf__string(v.Values, ok); err != nil { 4322 return err 4323 } 4324 } 4325 4326 return nil 4327} 4328 4329func awsRestjson1_serializeDocumentSortCriteria(v *types.SortCriteria, value smithyjson.Value) error { 4330 object := value.Object() 4331 defer object.Close() 4332 4333 if v.AttributeName != nil { 4334 ok := object.Key("attributeName") 4335 ok.String(*v.AttributeName) 4336 } 4337 4338 if len(v.OrderBy) > 0 { 4339 ok := object.Key("orderBy") 4340 ok.String(string(v.OrderBy)) 4341 } 4342 4343 return nil 4344} 4345 4346func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 4347 object := value.Object() 4348 defer object.Close() 4349 4350 for key := range v { 4351 om := object.Key(key) 4352 om.String(v[key]) 4353 } 4354 return nil 4355} 4356 4357func awsRestjson1_serializeDocumentTagScopeTerm(v *types.TagScopeTerm, value smithyjson.Value) error { 4358 object := value.Object() 4359 defer object.Close() 4360 4361 if len(v.Comparator) > 0 { 4362 ok := object.Key("comparator") 4363 ok.String(string(v.Comparator)) 4364 } 4365 4366 if v.Key != nil { 4367 ok := object.Key("key") 4368 ok.String(*v.Key) 4369 } 4370 4371 if v.TagValues != nil { 4372 ok := object.Key("tagValues") 4373 if err := awsRestjson1_serializeDocument__listOfTagValuePair(v.TagValues, ok); err != nil { 4374 return err 4375 } 4376 } 4377 4378 if len(v.Target) > 0 { 4379 ok := object.Key("target") 4380 ok.String(string(v.Target)) 4381 } 4382 4383 return nil 4384} 4385 4386func awsRestjson1_serializeDocumentTagValuePair(v *types.TagValuePair, value smithyjson.Value) error { 4387 object := value.Object() 4388 defer object.Close() 4389 4390 if v.Key != nil { 4391 ok := object.Key("key") 4392 ok.String(*v.Key) 4393 } 4394 4395 if v.Value != nil { 4396 ok := object.Key("value") 4397 ok.String(*v.Value) 4398 } 4399 4400 return nil 4401} 4402 4403func awsRestjson1_serializeDocumentUsageStatisticsFilter(v *types.UsageStatisticsFilter, value smithyjson.Value) error { 4404 object := value.Object() 4405 defer object.Close() 4406 4407 if len(v.Comparator) > 0 { 4408 ok := object.Key("comparator") 4409 ok.String(string(v.Comparator)) 4410 } 4411 4412 if len(v.Key) > 0 { 4413 ok := object.Key("key") 4414 ok.String(string(v.Key)) 4415 } 4416 4417 if v.Values != nil { 4418 ok := object.Key("values") 4419 if err := awsRestjson1_serializeDocument__listOf__string(v.Values, ok); err != nil { 4420 return err 4421 } 4422 } 4423 4424 return nil 4425} 4426 4427func awsRestjson1_serializeDocumentUsageStatisticsSortBy(v *types.UsageStatisticsSortBy, value smithyjson.Value) error { 4428 object := value.Object() 4429 defer object.Close() 4430 4431 if len(v.Key) > 0 { 4432 ok := object.Key("key") 4433 ok.String(string(v.Key)) 4434 } 4435 4436 if len(v.OrderBy) > 0 { 4437 ok := object.Key("orderBy") 4438 ok.String(string(v.OrderBy)) 4439 } 4440 4441 return nil 4442} 4443 4444func awsRestjson1_serializeDocumentWeeklySchedule(v *types.WeeklySchedule, value smithyjson.Value) error { 4445 object := value.Object() 4446 defer object.Close() 4447 4448 if len(v.DayOfWeek) > 0 { 4449 ok := object.Key("dayOfWeek") 4450 ok.String(string(v.DayOfWeek)) 4451 } 4452 4453 return nil 4454} 4455