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