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