1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package commander 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/commander/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 smithytime "github.com/aws/smithy-go/time" 15 smithyhttp "github.com/aws/smithy-go/transport/http" 16) 17 18type awsRestjson1_serializeOpCreateReplicationSet struct { 19} 20 21func (*awsRestjson1_serializeOpCreateReplicationSet) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpCreateReplicationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 26 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 27) { 28 request, ok := in.Request.(*smithyhttp.Request) 29 if !ok { 30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 31 } 32 33 input, ok := in.Parameters.(*CreateReplicationSetInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 opPath, opQuery := httpbinding.SplitURI("/createReplicationSet") 40 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 41 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 42 request.Method = "POST" 43 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 44 if err != nil { 45 return out, metadata, &smithy.SerializationError{Err: err} 46 } 47 48 restEncoder.SetHeader("Content-Type").String("application/json") 49 50 jsonEncoder := smithyjson.NewEncoder() 51 if err := awsRestjson1_serializeOpDocumentCreateReplicationSetInput(input, jsonEncoder.Value); err != nil { 52 return out, metadata, &smithy.SerializationError{Err: err} 53 } 54 55 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 56 return out, metadata, &smithy.SerializationError{Err: err} 57 } 58 59 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 in.Request = request 63 64 return next.HandleSerialize(ctx, in) 65} 66func awsRestjson1_serializeOpHttpBindingsCreateReplicationSetInput(v *CreateReplicationSetInput, encoder *httpbinding.Encoder) error { 67 if v == nil { 68 return fmt.Errorf("unsupported serialization of nil %T", v) 69 } 70 71 return nil 72} 73 74func awsRestjson1_serializeOpDocumentCreateReplicationSetInput(v *CreateReplicationSetInput, value smithyjson.Value) error { 75 object := value.Object() 76 defer object.Close() 77 78 if v.ClientToken != nil { 79 ok := object.Key("clientToken") 80 ok.String(*v.ClientToken) 81 } 82 83 if v.Regions != nil { 84 ok := object.Key("regions") 85 if err := awsRestjson1_serializeDocumentRegionMapInput(v.Regions, ok); err != nil { 86 return err 87 } 88 } 89 90 return nil 91} 92 93type awsRestjson1_serializeOpCreateResponsePlan struct { 94} 95 96func (*awsRestjson1_serializeOpCreateResponsePlan) ID() string { 97 return "OperationSerializer" 98} 99 100func (m *awsRestjson1_serializeOpCreateResponsePlan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 101 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 102) { 103 request, ok := in.Request.(*smithyhttp.Request) 104 if !ok { 105 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 106 } 107 108 input, ok := in.Parameters.(*CreateResponsePlanInput) 109 _ = input 110 if !ok { 111 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 112 } 113 114 opPath, opQuery := httpbinding.SplitURI("/createResponsePlan") 115 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 116 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 117 request.Method = "POST" 118 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 119 if err != nil { 120 return out, metadata, &smithy.SerializationError{Err: err} 121 } 122 123 restEncoder.SetHeader("Content-Type").String("application/json") 124 125 jsonEncoder := smithyjson.NewEncoder() 126 if err := awsRestjson1_serializeOpDocumentCreateResponsePlanInput(input, jsonEncoder.Value); err != nil { 127 return out, metadata, &smithy.SerializationError{Err: err} 128 } 129 130 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 131 return out, metadata, &smithy.SerializationError{Err: err} 132 } 133 134 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 135 return out, metadata, &smithy.SerializationError{Err: err} 136 } 137 in.Request = request 138 139 return next.HandleSerialize(ctx, in) 140} 141func awsRestjson1_serializeOpHttpBindingsCreateResponsePlanInput(v *CreateResponsePlanInput, encoder *httpbinding.Encoder) error { 142 if v == nil { 143 return fmt.Errorf("unsupported serialization of nil %T", v) 144 } 145 146 return nil 147} 148 149func awsRestjson1_serializeOpDocumentCreateResponsePlanInput(v *CreateResponsePlanInput, value smithyjson.Value) error { 150 object := value.Object() 151 defer object.Close() 152 153 if v.Actions != nil { 154 ok := object.Key("actions") 155 if err := awsRestjson1_serializeDocumentActionsList(v.Actions, ok); err != nil { 156 return err 157 } 158 } 159 160 if v.ChatChannel != nil { 161 ok := object.Key("chatChannel") 162 if err := awsRestjson1_serializeDocumentChatChannel(v.ChatChannel, ok); err != nil { 163 return err 164 } 165 } 166 167 if v.ClientToken != nil { 168 ok := object.Key("clientToken") 169 ok.String(*v.ClientToken) 170 } 171 172 if v.DisplayName != nil { 173 ok := object.Key("displayName") 174 ok.String(*v.DisplayName) 175 } 176 177 if v.Engagements != nil { 178 ok := object.Key("engagements") 179 if err := awsRestjson1_serializeDocumentEngagementSet(v.Engagements, ok); err != nil { 180 return err 181 } 182 } 183 184 if v.IncidentTemplate != nil { 185 ok := object.Key("incidentTemplate") 186 if err := awsRestjson1_serializeDocumentIncidentTemplate(v.IncidentTemplate, ok); err != nil { 187 return err 188 } 189 } 190 191 if v.Name != nil { 192 ok := object.Key("name") 193 ok.String(*v.Name) 194 } 195 196 if v.Tags != nil { 197 ok := object.Key("tags") 198 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 199 return err 200 } 201 } 202 203 return nil 204} 205 206type awsRestjson1_serializeOpCreateTimelineEvent struct { 207} 208 209func (*awsRestjson1_serializeOpCreateTimelineEvent) ID() string { 210 return "OperationSerializer" 211} 212 213func (m *awsRestjson1_serializeOpCreateTimelineEvent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 214 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 215) { 216 request, ok := in.Request.(*smithyhttp.Request) 217 if !ok { 218 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 219 } 220 221 input, ok := in.Parameters.(*CreateTimelineEventInput) 222 _ = input 223 if !ok { 224 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 225 } 226 227 opPath, opQuery := httpbinding.SplitURI("/createTimelineEvent") 228 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 229 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 230 request.Method = "POST" 231 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 232 if err != nil { 233 return out, metadata, &smithy.SerializationError{Err: err} 234 } 235 236 restEncoder.SetHeader("Content-Type").String("application/json") 237 238 jsonEncoder := smithyjson.NewEncoder() 239 if err := awsRestjson1_serializeOpDocumentCreateTimelineEventInput(input, jsonEncoder.Value); err != nil { 240 return out, metadata, &smithy.SerializationError{Err: err} 241 } 242 243 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 244 return out, metadata, &smithy.SerializationError{Err: err} 245 } 246 247 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 248 return out, metadata, &smithy.SerializationError{Err: err} 249 } 250 in.Request = request 251 252 return next.HandleSerialize(ctx, in) 253} 254func awsRestjson1_serializeOpHttpBindingsCreateTimelineEventInput(v *CreateTimelineEventInput, encoder *httpbinding.Encoder) error { 255 if v == nil { 256 return fmt.Errorf("unsupported serialization of nil %T", v) 257 } 258 259 return nil 260} 261 262func awsRestjson1_serializeOpDocumentCreateTimelineEventInput(v *CreateTimelineEventInput, value smithyjson.Value) error { 263 object := value.Object() 264 defer object.Close() 265 266 if v.ClientToken != nil { 267 ok := object.Key("clientToken") 268 ok.String(*v.ClientToken) 269 } 270 271 if v.EventData != nil { 272 ok := object.Key("eventData") 273 ok.String(*v.EventData) 274 } 275 276 if v.EventTime != nil { 277 ok := object.Key("eventTime") 278 ok.Double(smithytime.FormatEpochSeconds(*v.EventTime)) 279 } 280 281 if v.EventType != nil { 282 ok := object.Key("eventType") 283 ok.String(*v.EventType) 284 } 285 286 if v.IncidentRecordArn != nil { 287 ok := object.Key("incidentRecordArn") 288 ok.String(*v.IncidentRecordArn) 289 } 290 291 return nil 292} 293 294type awsRestjson1_serializeOpDeleteIncidentRecord struct { 295} 296 297func (*awsRestjson1_serializeOpDeleteIncidentRecord) ID() string { 298 return "OperationSerializer" 299} 300 301func (m *awsRestjson1_serializeOpDeleteIncidentRecord) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 302 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 303) { 304 request, ok := in.Request.(*smithyhttp.Request) 305 if !ok { 306 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 307 } 308 309 input, ok := in.Parameters.(*DeleteIncidentRecordInput) 310 _ = input 311 if !ok { 312 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 313 } 314 315 opPath, opQuery := httpbinding.SplitURI("/deleteIncidentRecord") 316 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 317 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 318 request.Method = "POST" 319 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 320 if err != nil { 321 return out, metadata, &smithy.SerializationError{Err: err} 322 } 323 324 restEncoder.SetHeader("Content-Type").String("application/json") 325 326 jsonEncoder := smithyjson.NewEncoder() 327 if err := awsRestjson1_serializeOpDocumentDeleteIncidentRecordInput(input, jsonEncoder.Value); err != nil { 328 return out, metadata, &smithy.SerializationError{Err: err} 329 } 330 331 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 332 return out, metadata, &smithy.SerializationError{Err: err} 333 } 334 335 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 336 return out, metadata, &smithy.SerializationError{Err: err} 337 } 338 in.Request = request 339 340 return next.HandleSerialize(ctx, in) 341} 342func awsRestjson1_serializeOpHttpBindingsDeleteIncidentRecordInput(v *DeleteIncidentRecordInput, encoder *httpbinding.Encoder) error { 343 if v == nil { 344 return fmt.Errorf("unsupported serialization of nil %T", v) 345 } 346 347 return nil 348} 349 350func awsRestjson1_serializeOpDocumentDeleteIncidentRecordInput(v *DeleteIncidentRecordInput, value smithyjson.Value) error { 351 object := value.Object() 352 defer object.Close() 353 354 if v.Arn != nil { 355 ok := object.Key("arn") 356 ok.String(*v.Arn) 357 } 358 359 return nil 360} 361 362type awsRestjson1_serializeOpDeleteReplicationSet struct { 363} 364 365func (*awsRestjson1_serializeOpDeleteReplicationSet) ID() string { 366 return "OperationSerializer" 367} 368 369func (m *awsRestjson1_serializeOpDeleteReplicationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 370 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 371) { 372 request, ok := in.Request.(*smithyhttp.Request) 373 if !ok { 374 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 375 } 376 377 input, ok := in.Parameters.(*DeleteReplicationSetInput) 378 _ = input 379 if !ok { 380 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 381 } 382 383 opPath, opQuery := httpbinding.SplitURI("/deleteReplicationSet") 384 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 385 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 386 request.Method = "POST" 387 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 388 if err != nil { 389 return out, metadata, &smithy.SerializationError{Err: err} 390 } 391 392 if err := awsRestjson1_serializeOpHttpBindingsDeleteReplicationSetInput(input, restEncoder); err != nil { 393 return out, metadata, &smithy.SerializationError{Err: err} 394 } 395 396 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 397 return out, metadata, &smithy.SerializationError{Err: err} 398 } 399 in.Request = request 400 401 return next.HandleSerialize(ctx, in) 402} 403func awsRestjson1_serializeOpHttpBindingsDeleteReplicationSetInput(v *DeleteReplicationSetInput, encoder *httpbinding.Encoder) error { 404 if v == nil { 405 return fmt.Errorf("unsupported serialization of nil %T", v) 406 } 407 408 if v.Arn != nil { 409 encoder.SetQuery("arn").String(*v.Arn) 410 } 411 412 return nil 413} 414 415type awsRestjson1_serializeOpDeleteResourcePolicy struct { 416} 417 418func (*awsRestjson1_serializeOpDeleteResourcePolicy) ID() string { 419 return "OperationSerializer" 420} 421 422func (m *awsRestjson1_serializeOpDeleteResourcePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 423 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 424) { 425 request, ok := in.Request.(*smithyhttp.Request) 426 if !ok { 427 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 428 } 429 430 input, ok := in.Parameters.(*DeleteResourcePolicyInput) 431 _ = input 432 if !ok { 433 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 434 } 435 436 opPath, opQuery := httpbinding.SplitURI("/deleteResourcePolicy") 437 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 438 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 439 request.Method = "POST" 440 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 441 if err != nil { 442 return out, metadata, &smithy.SerializationError{Err: err} 443 } 444 445 restEncoder.SetHeader("Content-Type").String("application/json") 446 447 jsonEncoder := smithyjson.NewEncoder() 448 if err := awsRestjson1_serializeOpDocumentDeleteResourcePolicyInput(input, jsonEncoder.Value); err != nil { 449 return out, metadata, &smithy.SerializationError{Err: err} 450 } 451 452 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 453 return out, metadata, &smithy.SerializationError{Err: err} 454 } 455 456 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 457 return out, metadata, &smithy.SerializationError{Err: err} 458 } 459 in.Request = request 460 461 return next.HandleSerialize(ctx, in) 462} 463func awsRestjson1_serializeOpHttpBindingsDeleteResourcePolicyInput(v *DeleteResourcePolicyInput, encoder *httpbinding.Encoder) error { 464 if v == nil { 465 return fmt.Errorf("unsupported serialization of nil %T", v) 466 } 467 468 return nil 469} 470 471func awsRestjson1_serializeOpDocumentDeleteResourcePolicyInput(v *DeleteResourcePolicyInput, value smithyjson.Value) error { 472 object := value.Object() 473 defer object.Close() 474 475 if v.PolicyId != nil { 476 ok := object.Key("policyId") 477 ok.String(*v.PolicyId) 478 } 479 480 if v.ResourceArn != nil { 481 ok := object.Key("resourceArn") 482 ok.String(*v.ResourceArn) 483 } 484 485 return nil 486} 487 488type awsRestjson1_serializeOpDeleteResponsePlan struct { 489} 490 491func (*awsRestjson1_serializeOpDeleteResponsePlan) ID() string { 492 return "OperationSerializer" 493} 494 495func (m *awsRestjson1_serializeOpDeleteResponsePlan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 496 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 497) { 498 request, ok := in.Request.(*smithyhttp.Request) 499 if !ok { 500 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 501 } 502 503 input, ok := in.Parameters.(*DeleteResponsePlanInput) 504 _ = input 505 if !ok { 506 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 507 } 508 509 opPath, opQuery := httpbinding.SplitURI("/deleteResponsePlan") 510 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 511 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 512 request.Method = "POST" 513 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 514 if err != nil { 515 return out, metadata, &smithy.SerializationError{Err: err} 516 } 517 518 restEncoder.SetHeader("Content-Type").String("application/json") 519 520 jsonEncoder := smithyjson.NewEncoder() 521 if err := awsRestjson1_serializeOpDocumentDeleteResponsePlanInput(input, jsonEncoder.Value); err != nil { 522 return out, metadata, &smithy.SerializationError{Err: err} 523 } 524 525 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 526 return out, metadata, &smithy.SerializationError{Err: err} 527 } 528 529 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 530 return out, metadata, &smithy.SerializationError{Err: err} 531 } 532 in.Request = request 533 534 return next.HandleSerialize(ctx, in) 535} 536func awsRestjson1_serializeOpHttpBindingsDeleteResponsePlanInput(v *DeleteResponsePlanInput, encoder *httpbinding.Encoder) error { 537 if v == nil { 538 return fmt.Errorf("unsupported serialization of nil %T", v) 539 } 540 541 return nil 542} 543 544func awsRestjson1_serializeOpDocumentDeleteResponsePlanInput(v *DeleteResponsePlanInput, value smithyjson.Value) error { 545 object := value.Object() 546 defer object.Close() 547 548 if v.Arn != nil { 549 ok := object.Key("arn") 550 ok.String(*v.Arn) 551 } 552 553 return nil 554} 555 556type awsRestjson1_serializeOpDeleteTimelineEvent struct { 557} 558 559func (*awsRestjson1_serializeOpDeleteTimelineEvent) ID() string { 560 return "OperationSerializer" 561} 562 563func (m *awsRestjson1_serializeOpDeleteTimelineEvent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 564 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 565) { 566 request, ok := in.Request.(*smithyhttp.Request) 567 if !ok { 568 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 569 } 570 571 input, ok := in.Parameters.(*DeleteTimelineEventInput) 572 _ = input 573 if !ok { 574 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 575 } 576 577 opPath, opQuery := httpbinding.SplitURI("/deleteTimelineEvent") 578 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 579 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 580 request.Method = "POST" 581 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 582 if err != nil { 583 return out, metadata, &smithy.SerializationError{Err: err} 584 } 585 586 restEncoder.SetHeader("Content-Type").String("application/json") 587 588 jsonEncoder := smithyjson.NewEncoder() 589 if err := awsRestjson1_serializeOpDocumentDeleteTimelineEventInput(input, jsonEncoder.Value); err != nil { 590 return out, metadata, &smithy.SerializationError{Err: err} 591 } 592 593 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 594 return out, metadata, &smithy.SerializationError{Err: err} 595 } 596 597 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 598 return out, metadata, &smithy.SerializationError{Err: err} 599 } 600 in.Request = request 601 602 return next.HandleSerialize(ctx, in) 603} 604func awsRestjson1_serializeOpHttpBindingsDeleteTimelineEventInput(v *DeleteTimelineEventInput, encoder *httpbinding.Encoder) error { 605 if v == nil { 606 return fmt.Errorf("unsupported serialization of nil %T", v) 607 } 608 609 return nil 610} 611 612func awsRestjson1_serializeOpDocumentDeleteTimelineEventInput(v *DeleteTimelineEventInput, value smithyjson.Value) error { 613 object := value.Object() 614 defer object.Close() 615 616 if v.EventId != nil { 617 ok := object.Key("eventId") 618 ok.String(*v.EventId) 619 } 620 621 if v.IncidentRecordArn != nil { 622 ok := object.Key("incidentRecordArn") 623 ok.String(*v.IncidentRecordArn) 624 } 625 626 return nil 627} 628 629type awsRestjson1_serializeOpGetIncidentRecord struct { 630} 631 632func (*awsRestjson1_serializeOpGetIncidentRecord) ID() string { 633 return "OperationSerializer" 634} 635 636func (m *awsRestjson1_serializeOpGetIncidentRecord) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 637 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 638) { 639 request, ok := in.Request.(*smithyhttp.Request) 640 if !ok { 641 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 642 } 643 644 input, ok := in.Parameters.(*GetIncidentRecordInput) 645 _ = input 646 if !ok { 647 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 648 } 649 650 opPath, opQuery := httpbinding.SplitURI("/getIncidentRecord") 651 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 652 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 653 request.Method = "GET" 654 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 655 if err != nil { 656 return out, metadata, &smithy.SerializationError{Err: err} 657 } 658 659 if err := awsRestjson1_serializeOpHttpBindingsGetIncidentRecordInput(input, restEncoder); err != nil { 660 return out, metadata, &smithy.SerializationError{Err: err} 661 } 662 663 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 664 return out, metadata, &smithy.SerializationError{Err: err} 665 } 666 in.Request = request 667 668 return next.HandleSerialize(ctx, in) 669} 670func awsRestjson1_serializeOpHttpBindingsGetIncidentRecordInput(v *GetIncidentRecordInput, encoder *httpbinding.Encoder) error { 671 if v == nil { 672 return fmt.Errorf("unsupported serialization of nil %T", v) 673 } 674 675 if v.Arn != nil { 676 encoder.SetQuery("arn").String(*v.Arn) 677 } 678 679 return nil 680} 681 682type awsRestjson1_serializeOpGetReplicationSet struct { 683} 684 685func (*awsRestjson1_serializeOpGetReplicationSet) ID() string { 686 return "OperationSerializer" 687} 688 689func (m *awsRestjson1_serializeOpGetReplicationSet) 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.(*GetReplicationSetInput) 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("/getReplicationSet") 704 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 705 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 706 request.Method = "GET" 707 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 708 if err != nil { 709 return out, metadata, &smithy.SerializationError{Err: err} 710 } 711 712 if err := awsRestjson1_serializeOpHttpBindingsGetReplicationSetInput(input, restEncoder); err != nil { 713 return out, metadata, &smithy.SerializationError{Err: err} 714 } 715 716 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 717 return out, metadata, &smithy.SerializationError{Err: err} 718 } 719 in.Request = request 720 721 return next.HandleSerialize(ctx, in) 722} 723func awsRestjson1_serializeOpHttpBindingsGetReplicationSetInput(v *GetReplicationSetInput, encoder *httpbinding.Encoder) error { 724 if v == nil { 725 return fmt.Errorf("unsupported serialization of nil %T", v) 726 } 727 728 if v.Arn != nil { 729 encoder.SetQuery("arn").String(*v.Arn) 730 } 731 732 return nil 733} 734 735type awsRestjson1_serializeOpGetResourcePolicies struct { 736} 737 738func (*awsRestjson1_serializeOpGetResourcePolicies) ID() string { 739 return "OperationSerializer" 740} 741 742func (m *awsRestjson1_serializeOpGetResourcePolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 743 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 744) { 745 request, ok := in.Request.(*smithyhttp.Request) 746 if !ok { 747 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 748 } 749 750 input, ok := in.Parameters.(*GetResourcePoliciesInput) 751 _ = input 752 if !ok { 753 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 754 } 755 756 opPath, opQuery := httpbinding.SplitURI("/getResourcePolicies") 757 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 758 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 759 request.Method = "POST" 760 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 761 if err != nil { 762 return out, metadata, &smithy.SerializationError{Err: err} 763 } 764 765 if err := awsRestjson1_serializeOpHttpBindingsGetResourcePoliciesInput(input, restEncoder); err != nil { 766 return out, metadata, &smithy.SerializationError{Err: err} 767 } 768 769 restEncoder.SetHeader("Content-Type").String("application/json") 770 771 jsonEncoder := smithyjson.NewEncoder() 772 if err := awsRestjson1_serializeOpDocumentGetResourcePoliciesInput(input, jsonEncoder.Value); err != nil { 773 return out, metadata, &smithy.SerializationError{Err: err} 774 } 775 776 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 777 return out, metadata, &smithy.SerializationError{Err: err} 778 } 779 780 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 781 return out, metadata, &smithy.SerializationError{Err: err} 782 } 783 in.Request = request 784 785 return next.HandleSerialize(ctx, in) 786} 787func awsRestjson1_serializeOpHttpBindingsGetResourcePoliciesInput(v *GetResourcePoliciesInput, encoder *httpbinding.Encoder) error { 788 if v == nil { 789 return fmt.Errorf("unsupported serialization of nil %T", v) 790 } 791 792 if v.ResourceArn != nil { 793 encoder.SetQuery("resourceArn").String(*v.ResourceArn) 794 } 795 796 return nil 797} 798 799func awsRestjson1_serializeOpDocumentGetResourcePoliciesInput(v *GetResourcePoliciesInput, value smithyjson.Value) error { 800 object := value.Object() 801 defer object.Close() 802 803 if v.MaxResults != nil { 804 ok := object.Key("maxResults") 805 ok.Integer(*v.MaxResults) 806 } 807 808 if v.NextToken != nil { 809 ok := object.Key("nextToken") 810 ok.String(*v.NextToken) 811 } 812 813 return nil 814} 815 816type awsRestjson1_serializeOpGetResponsePlan struct { 817} 818 819func (*awsRestjson1_serializeOpGetResponsePlan) ID() string { 820 return "OperationSerializer" 821} 822 823func (m *awsRestjson1_serializeOpGetResponsePlan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 824 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 825) { 826 request, ok := in.Request.(*smithyhttp.Request) 827 if !ok { 828 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 829 } 830 831 input, ok := in.Parameters.(*GetResponsePlanInput) 832 _ = input 833 if !ok { 834 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 835 } 836 837 opPath, opQuery := httpbinding.SplitURI("/getResponsePlan") 838 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 839 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 840 request.Method = "GET" 841 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 842 if err != nil { 843 return out, metadata, &smithy.SerializationError{Err: err} 844 } 845 846 if err := awsRestjson1_serializeOpHttpBindingsGetResponsePlanInput(input, restEncoder); err != nil { 847 return out, metadata, &smithy.SerializationError{Err: err} 848 } 849 850 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 851 return out, metadata, &smithy.SerializationError{Err: err} 852 } 853 in.Request = request 854 855 return next.HandleSerialize(ctx, in) 856} 857func awsRestjson1_serializeOpHttpBindingsGetResponsePlanInput(v *GetResponsePlanInput, encoder *httpbinding.Encoder) error { 858 if v == nil { 859 return fmt.Errorf("unsupported serialization of nil %T", v) 860 } 861 862 if v.Arn != nil { 863 encoder.SetQuery("arn").String(*v.Arn) 864 } 865 866 return nil 867} 868 869type awsRestjson1_serializeOpGetTimelineEvent struct { 870} 871 872func (*awsRestjson1_serializeOpGetTimelineEvent) ID() string { 873 return "OperationSerializer" 874} 875 876func (m *awsRestjson1_serializeOpGetTimelineEvent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 877 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 878) { 879 request, ok := in.Request.(*smithyhttp.Request) 880 if !ok { 881 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 882 } 883 884 input, ok := in.Parameters.(*GetTimelineEventInput) 885 _ = input 886 if !ok { 887 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 888 } 889 890 opPath, opQuery := httpbinding.SplitURI("/getTimelineEvent") 891 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 892 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 893 request.Method = "GET" 894 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 895 if err != nil { 896 return out, metadata, &smithy.SerializationError{Err: err} 897 } 898 899 if err := awsRestjson1_serializeOpHttpBindingsGetTimelineEventInput(input, restEncoder); err != nil { 900 return out, metadata, &smithy.SerializationError{Err: err} 901 } 902 903 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 904 return out, metadata, &smithy.SerializationError{Err: err} 905 } 906 in.Request = request 907 908 return next.HandleSerialize(ctx, in) 909} 910func awsRestjson1_serializeOpHttpBindingsGetTimelineEventInput(v *GetTimelineEventInput, encoder *httpbinding.Encoder) error { 911 if v == nil { 912 return fmt.Errorf("unsupported serialization of nil %T", v) 913 } 914 915 if v.EventId != nil { 916 encoder.SetQuery("eventId").String(*v.EventId) 917 } 918 919 if v.IncidentRecordArn != nil { 920 encoder.SetQuery("incidentRecordArn").String(*v.IncidentRecordArn) 921 } 922 923 return nil 924} 925 926type awsRestjson1_serializeOpListIncidentRecords struct { 927} 928 929func (*awsRestjson1_serializeOpListIncidentRecords) ID() string { 930 return "OperationSerializer" 931} 932 933func (m *awsRestjson1_serializeOpListIncidentRecords) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 934 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 935) { 936 request, ok := in.Request.(*smithyhttp.Request) 937 if !ok { 938 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 939 } 940 941 input, ok := in.Parameters.(*ListIncidentRecordsInput) 942 _ = input 943 if !ok { 944 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 945 } 946 947 opPath, opQuery := httpbinding.SplitURI("/listIncidentRecords") 948 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 949 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 950 request.Method = "POST" 951 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 952 if err != nil { 953 return out, metadata, &smithy.SerializationError{Err: err} 954 } 955 956 restEncoder.SetHeader("Content-Type").String("application/json") 957 958 jsonEncoder := smithyjson.NewEncoder() 959 if err := awsRestjson1_serializeOpDocumentListIncidentRecordsInput(input, jsonEncoder.Value); err != nil { 960 return out, metadata, &smithy.SerializationError{Err: err} 961 } 962 963 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 964 return out, metadata, &smithy.SerializationError{Err: err} 965 } 966 967 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 968 return out, metadata, &smithy.SerializationError{Err: err} 969 } 970 in.Request = request 971 972 return next.HandleSerialize(ctx, in) 973} 974func awsRestjson1_serializeOpHttpBindingsListIncidentRecordsInput(v *ListIncidentRecordsInput, encoder *httpbinding.Encoder) error { 975 if v == nil { 976 return fmt.Errorf("unsupported serialization of nil %T", v) 977 } 978 979 return nil 980} 981 982func awsRestjson1_serializeOpDocumentListIncidentRecordsInput(v *ListIncidentRecordsInput, value smithyjson.Value) error { 983 object := value.Object() 984 defer object.Close() 985 986 if v.Filters != nil { 987 ok := object.Key("filters") 988 if err := awsRestjson1_serializeDocumentFilterList(v.Filters, ok); err != nil { 989 return err 990 } 991 } 992 993 if v.MaxResults != nil { 994 ok := object.Key("maxResults") 995 ok.Integer(*v.MaxResults) 996 } 997 998 if v.NextToken != nil { 999 ok := object.Key("nextToken") 1000 ok.String(*v.NextToken) 1001 } 1002 1003 return nil 1004} 1005 1006type awsRestjson1_serializeOpListRelatedItems struct { 1007} 1008 1009func (*awsRestjson1_serializeOpListRelatedItems) ID() string { 1010 return "OperationSerializer" 1011} 1012 1013func (m *awsRestjson1_serializeOpListRelatedItems) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1014 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1015) { 1016 request, ok := in.Request.(*smithyhttp.Request) 1017 if !ok { 1018 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1019 } 1020 1021 input, ok := in.Parameters.(*ListRelatedItemsInput) 1022 _ = input 1023 if !ok { 1024 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1025 } 1026 1027 opPath, opQuery := httpbinding.SplitURI("/listRelatedItems") 1028 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1029 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1030 request.Method = "POST" 1031 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1032 if err != nil { 1033 return out, metadata, &smithy.SerializationError{Err: err} 1034 } 1035 1036 restEncoder.SetHeader("Content-Type").String("application/json") 1037 1038 jsonEncoder := smithyjson.NewEncoder() 1039 if err := awsRestjson1_serializeOpDocumentListRelatedItemsInput(input, jsonEncoder.Value); err != nil { 1040 return out, metadata, &smithy.SerializationError{Err: err} 1041 } 1042 1043 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1044 return out, metadata, &smithy.SerializationError{Err: err} 1045 } 1046 1047 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1048 return out, metadata, &smithy.SerializationError{Err: err} 1049 } 1050 in.Request = request 1051 1052 return next.HandleSerialize(ctx, in) 1053} 1054func awsRestjson1_serializeOpHttpBindingsListRelatedItemsInput(v *ListRelatedItemsInput, encoder *httpbinding.Encoder) error { 1055 if v == nil { 1056 return fmt.Errorf("unsupported serialization of nil %T", v) 1057 } 1058 1059 return nil 1060} 1061 1062func awsRestjson1_serializeOpDocumentListRelatedItemsInput(v *ListRelatedItemsInput, value smithyjson.Value) error { 1063 object := value.Object() 1064 defer object.Close() 1065 1066 if v.IncidentRecordArn != nil { 1067 ok := object.Key("incidentRecordArn") 1068 ok.String(*v.IncidentRecordArn) 1069 } 1070 1071 if v.MaxResults != nil { 1072 ok := object.Key("maxResults") 1073 ok.Integer(*v.MaxResults) 1074 } 1075 1076 if v.NextToken != nil { 1077 ok := object.Key("nextToken") 1078 ok.String(*v.NextToken) 1079 } 1080 1081 return nil 1082} 1083 1084type awsRestjson1_serializeOpListReplicationSets struct { 1085} 1086 1087func (*awsRestjson1_serializeOpListReplicationSets) ID() string { 1088 return "OperationSerializer" 1089} 1090 1091func (m *awsRestjson1_serializeOpListReplicationSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1092 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1093) { 1094 request, ok := in.Request.(*smithyhttp.Request) 1095 if !ok { 1096 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1097 } 1098 1099 input, ok := in.Parameters.(*ListReplicationSetsInput) 1100 _ = input 1101 if !ok { 1102 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1103 } 1104 1105 opPath, opQuery := httpbinding.SplitURI("/listReplicationSets") 1106 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1107 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1108 request.Method = "POST" 1109 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1110 if err != nil { 1111 return out, metadata, &smithy.SerializationError{Err: err} 1112 } 1113 1114 restEncoder.SetHeader("Content-Type").String("application/json") 1115 1116 jsonEncoder := smithyjson.NewEncoder() 1117 if err := awsRestjson1_serializeOpDocumentListReplicationSetsInput(input, jsonEncoder.Value); err != nil { 1118 return out, metadata, &smithy.SerializationError{Err: err} 1119 } 1120 1121 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1122 return out, metadata, &smithy.SerializationError{Err: err} 1123 } 1124 1125 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1126 return out, metadata, &smithy.SerializationError{Err: err} 1127 } 1128 in.Request = request 1129 1130 return next.HandleSerialize(ctx, in) 1131} 1132func awsRestjson1_serializeOpHttpBindingsListReplicationSetsInput(v *ListReplicationSetsInput, encoder *httpbinding.Encoder) error { 1133 if v == nil { 1134 return fmt.Errorf("unsupported serialization of nil %T", v) 1135 } 1136 1137 return nil 1138} 1139 1140func awsRestjson1_serializeOpDocumentListReplicationSetsInput(v *ListReplicationSetsInput, value smithyjson.Value) error { 1141 object := value.Object() 1142 defer object.Close() 1143 1144 if v.MaxResults != nil { 1145 ok := object.Key("maxResults") 1146 ok.Integer(*v.MaxResults) 1147 } 1148 1149 if v.NextToken != nil { 1150 ok := object.Key("nextToken") 1151 ok.String(*v.NextToken) 1152 } 1153 1154 return nil 1155} 1156 1157type awsRestjson1_serializeOpListResponsePlans struct { 1158} 1159 1160func (*awsRestjson1_serializeOpListResponsePlans) ID() string { 1161 return "OperationSerializer" 1162} 1163 1164func (m *awsRestjson1_serializeOpListResponsePlans) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1165 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1166) { 1167 request, ok := in.Request.(*smithyhttp.Request) 1168 if !ok { 1169 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1170 } 1171 1172 input, ok := in.Parameters.(*ListResponsePlansInput) 1173 _ = input 1174 if !ok { 1175 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1176 } 1177 1178 opPath, opQuery := httpbinding.SplitURI("/listResponsePlans") 1179 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1180 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1181 request.Method = "POST" 1182 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1183 if err != nil { 1184 return out, metadata, &smithy.SerializationError{Err: err} 1185 } 1186 1187 restEncoder.SetHeader("Content-Type").String("application/json") 1188 1189 jsonEncoder := smithyjson.NewEncoder() 1190 if err := awsRestjson1_serializeOpDocumentListResponsePlansInput(input, jsonEncoder.Value); err != nil { 1191 return out, metadata, &smithy.SerializationError{Err: err} 1192 } 1193 1194 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1195 return out, metadata, &smithy.SerializationError{Err: err} 1196 } 1197 1198 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1199 return out, metadata, &smithy.SerializationError{Err: err} 1200 } 1201 in.Request = request 1202 1203 return next.HandleSerialize(ctx, in) 1204} 1205func awsRestjson1_serializeOpHttpBindingsListResponsePlansInput(v *ListResponsePlansInput, encoder *httpbinding.Encoder) error { 1206 if v == nil { 1207 return fmt.Errorf("unsupported serialization of nil %T", v) 1208 } 1209 1210 return nil 1211} 1212 1213func awsRestjson1_serializeOpDocumentListResponsePlansInput(v *ListResponsePlansInput, value smithyjson.Value) error { 1214 object := value.Object() 1215 defer object.Close() 1216 1217 if v.MaxResults != nil { 1218 ok := object.Key("maxResults") 1219 ok.Integer(*v.MaxResults) 1220 } 1221 1222 if v.NextToken != nil { 1223 ok := object.Key("nextToken") 1224 ok.String(*v.NextToken) 1225 } 1226 1227 return nil 1228} 1229 1230type awsRestjson1_serializeOpListTagsForResource struct { 1231} 1232 1233func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 1234 return "OperationSerializer" 1235} 1236 1237func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1238 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1239) { 1240 request, ok := in.Request.(*smithyhttp.Request) 1241 if !ok { 1242 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1243 } 1244 1245 input, ok := in.Parameters.(*ListTagsForResourceInput) 1246 _ = input 1247 if !ok { 1248 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1249 } 1250 1251 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 1252 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1253 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1254 request.Method = "GET" 1255 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1256 if err != nil { 1257 return out, metadata, &smithy.SerializationError{Err: err} 1258 } 1259 1260 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 1261 return out, metadata, &smithy.SerializationError{Err: err} 1262 } 1263 1264 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1265 return out, metadata, &smithy.SerializationError{Err: err} 1266 } 1267 in.Request = request 1268 1269 return next.HandleSerialize(ctx, in) 1270} 1271func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1272 if v == nil { 1273 return fmt.Errorf("unsupported serialization of nil %T", v) 1274 } 1275 1276 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1277 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 1278 } 1279 if v.ResourceArn != nil { 1280 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 1281 return err 1282 } 1283 } 1284 1285 return nil 1286} 1287 1288type awsRestjson1_serializeOpListTimelineEvents struct { 1289} 1290 1291func (*awsRestjson1_serializeOpListTimelineEvents) ID() string { 1292 return "OperationSerializer" 1293} 1294 1295func (m *awsRestjson1_serializeOpListTimelineEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1296 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1297) { 1298 request, ok := in.Request.(*smithyhttp.Request) 1299 if !ok { 1300 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1301 } 1302 1303 input, ok := in.Parameters.(*ListTimelineEventsInput) 1304 _ = input 1305 if !ok { 1306 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1307 } 1308 1309 opPath, opQuery := httpbinding.SplitURI("/listTimelineEvents") 1310 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1311 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1312 request.Method = "POST" 1313 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1314 if err != nil { 1315 return out, metadata, &smithy.SerializationError{Err: err} 1316 } 1317 1318 restEncoder.SetHeader("Content-Type").String("application/json") 1319 1320 jsonEncoder := smithyjson.NewEncoder() 1321 if err := awsRestjson1_serializeOpDocumentListTimelineEventsInput(input, jsonEncoder.Value); err != nil { 1322 return out, metadata, &smithy.SerializationError{Err: err} 1323 } 1324 1325 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1326 return out, metadata, &smithy.SerializationError{Err: err} 1327 } 1328 1329 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1330 return out, metadata, &smithy.SerializationError{Err: err} 1331 } 1332 in.Request = request 1333 1334 return next.HandleSerialize(ctx, in) 1335} 1336func awsRestjson1_serializeOpHttpBindingsListTimelineEventsInput(v *ListTimelineEventsInput, encoder *httpbinding.Encoder) error { 1337 if v == nil { 1338 return fmt.Errorf("unsupported serialization of nil %T", v) 1339 } 1340 1341 return nil 1342} 1343 1344func awsRestjson1_serializeOpDocumentListTimelineEventsInput(v *ListTimelineEventsInput, value smithyjson.Value) error { 1345 object := value.Object() 1346 defer object.Close() 1347 1348 if v.Filters != nil { 1349 ok := object.Key("filters") 1350 if err := awsRestjson1_serializeDocumentFilterList(v.Filters, ok); err != nil { 1351 return err 1352 } 1353 } 1354 1355 if v.IncidentRecordArn != nil { 1356 ok := object.Key("incidentRecordArn") 1357 ok.String(*v.IncidentRecordArn) 1358 } 1359 1360 if v.MaxResults != nil { 1361 ok := object.Key("maxResults") 1362 ok.Integer(*v.MaxResults) 1363 } 1364 1365 if v.NextToken != nil { 1366 ok := object.Key("nextToken") 1367 ok.String(*v.NextToken) 1368 } 1369 1370 if len(v.SortBy) > 0 { 1371 ok := object.Key("sortBy") 1372 ok.String(string(v.SortBy)) 1373 } 1374 1375 if len(v.SortOrder) > 0 { 1376 ok := object.Key("sortOrder") 1377 ok.String(string(v.SortOrder)) 1378 } 1379 1380 return nil 1381} 1382 1383type awsRestjson1_serializeOpPutResourcePolicy struct { 1384} 1385 1386func (*awsRestjson1_serializeOpPutResourcePolicy) ID() string { 1387 return "OperationSerializer" 1388} 1389 1390func (m *awsRestjson1_serializeOpPutResourcePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1391 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1392) { 1393 request, ok := in.Request.(*smithyhttp.Request) 1394 if !ok { 1395 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1396 } 1397 1398 input, ok := in.Parameters.(*PutResourcePolicyInput) 1399 _ = input 1400 if !ok { 1401 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1402 } 1403 1404 opPath, opQuery := httpbinding.SplitURI("/putResourcePolicy") 1405 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1406 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1407 request.Method = "POST" 1408 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1409 if err != nil { 1410 return out, metadata, &smithy.SerializationError{Err: err} 1411 } 1412 1413 restEncoder.SetHeader("Content-Type").String("application/json") 1414 1415 jsonEncoder := smithyjson.NewEncoder() 1416 if err := awsRestjson1_serializeOpDocumentPutResourcePolicyInput(input, jsonEncoder.Value); err != nil { 1417 return out, metadata, &smithy.SerializationError{Err: err} 1418 } 1419 1420 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1421 return out, metadata, &smithy.SerializationError{Err: err} 1422 } 1423 1424 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1425 return out, metadata, &smithy.SerializationError{Err: err} 1426 } 1427 in.Request = request 1428 1429 return next.HandleSerialize(ctx, in) 1430} 1431func awsRestjson1_serializeOpHttpBindingsPutResourcePolicyInput(v *PutResourcePolicyInput, encoder *httpbinding.Encoder) error { 1432 if v == nil { 1433 return fmt.Errorf("unsupported serialization of nil %T", v) 1434 } 1435 1436 return nil 1437} 1438 1439func awsRestjson1_serializeOpDocumentPutResourcePolicyInput(v *PutResourcePolicyInput, value smithyjson.Value) error { 1440 object := value.Object() 1441 defer object.Close() 1442 1443 if v.Policy != nil { 1444 ok := object.Key("policy") 1445 ok.String(*v.Policy) 1446 } 1447 1448 if v.ResourceArn != nil { 1449 ok := object.Key("resourceArn") 1450 ok.String(*v.ResourceArn) 1451 } 1452 1453 return nil 1454} 1455 1456type awsRestjson1_serializeOpStartIncident struct { 1457} 1458 1459func (*awsRestjson1_serializeOpStartIncident) ID() string { 1460 return "OperationSerializer" 1461} 1462 1463func (m *awsRestjson1_serializeOpStartIncident) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1464 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1465) { 1466 request, ok := in.Request.(*smithyhttp.Request) 1467 if !ok { 1468 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1469 } 1470 1471 input, ok := in.Parameters.(*StartIncidentInput) 1472 _ = input 1473 if !ok { 1474 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1475 } 1476 1477 opPath, opQuery := httpbinding.SplitURI("/startIncident") 1478 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1479 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1480 request.Method = "POST" 1481 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1482 if err != nil { 1483 return out, metadata, &smithy.SerializationError{Err: err} 1484 } 1485 1486 restEncoder.SetHeader("Content-Type").String("application/json") 1487 1488 jsonEncoder := smithyjson.NewEncoder() 1489 if err := awsRestjson1_serializeOpDocumentStartIncidentInput(input, jsonEncoder.Value); err != nil { 1490 return out, metadata, &smithy.SerializationError{Err: err} 1491 } 1492 1493 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1494 return out, metadata, &smithy.SerializationError{Err: err} 1495 } 1496 1497 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1498 return out, metadata, &smithy.SerializationError{Err: err} 1499 } 1500 in.Request = request 1501 1502 return next.HandleSerialize(ctx, in) 1503} 1504func awsRestjson1_serializeOpHttpBindingsStartIncidentInput(v *StartIncidentInput, encoder *httpbinding.Encoder) error { 1505 if v == nil { 1506 return fmt.Errorf("unsupported serialization of nil %T", v) 1507 } 1508 1509 return nil 1510} 1511 1512func awsRestjson1_serializeOpDocumentStartIncidentInput(v *StartIncidentInput, value smithyjson.Value) error { 1513 object := value.Object() 1514 defer object.Close() 1515 1516 if v.ClientToken != nil { 1517 ok := object.Key("clientToken") 1518 ok.String(*v.ClientToken) 1519 } 1520 1521 if v.Impact != nil { 1522 ok := object.Key("impact") 1523 ok.Integer(*v.Impact) 1524 } 1525 1526 if v.RelatedItems != nil { 1527 ok := object.Key("relatedItems") 1528 if err := awsRestjson1_serializeDocumentRelatedItemList(v.RelatedItems, ok); err != nil { 1529 return err 1530 } 1531 } 1532 1533 if v.ResponsePlanArn != nil { 1534 ok := object.Key("responsePlanArn") 1535 ok.String(*v.ResponsePlanArn) 1536 } 1537 1538 if v.Title != nil { 1539 ok := object.Key("title") 1540 ok.String(*v.Title) 1541 } 1542 1543 if v.TriggerDetails != nil { 1544 ok := object.Key("triggerDetails") 1545 if err := awsRestjson1_serializeDocumentTriggerDetails(v.TriggerDetails, ok); err != nil { 1546 return err 1547 } 1548 } 1549 1550 return nil 1551} 1552 1553type awsRestjson1_serializeOpTagResource struct { 1554} 1555 1556func (*awsRestjson1_serializeOpTagResource) ID() string { 1557 return "OperationSerializer" 1558} 1559 1560func (m *awsRestjson1_serializeOpTagResource) 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.(*TagResourceInput) 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("/tags/{resourceArn}") 1575 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1576 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1577 request.Method = "POST" 1578 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1579 if err != nil { 1580 return out, metadata, &smithy.SerializationError{Err: err} 1581 } 1582 1583 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 1584 return out, metadata, &smithy.SerializationError{Err: err} 1585 } 1586 1587 restEncoder.SetHeader("Content-Type").String("application/json") 1588 1589 jsonEncoder := smithyjson.NewEncoder() 1590 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 1591 return out, metadata, &smithy.SerializationError{Err: err} 1592 } 1593 1594 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1595 return out, metadata, &smithy.SerializationError{Err: err} 1596 } 1597 1598 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1599 return out, metadata, &smithy.SerializationError{Err: err} 1600 } 1601 in.Request = request 1602 1603 return next.HandleSerialize(ctx, in) 1604} 1605func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 1606 if v == nil { 1607 return fmt.Errorf("unsupported serialization of nil %T", v) 1608 } 1609 1610 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1611 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 1612 } 1613 if v.ResourceArn != nil { 1614 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 1615 return err 1616 } 1617 } 1618 1619 return nil 1620} 1621 1622func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 1623 object := value.Object() 1624 defer object.Close() 1625 1626 if v.Tags != nil { 1627 ok := object.Key("tags") 1628 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1629 return err 1630 } 1631 } 1632 1633 return nil 1634} 1635 1636type awsRestjson1_serializeOpUntagResource struct { 1637} 1638 1639func (*awsRestjson1_serializeOpUntagResource) ID() string { 1640 return "OperationSerializer" 1641} 1642 1643func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1644 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1645) { 1646 request, ok := in.Request.(*smithyhttp.Request) 1647 if !ok { 1648 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1649 } 1650 1651 input, ok := in.Parameters.(*UntagResourceInput) 1652 _ = input 1653 if !ok { 1654 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1655 } 1656 1657 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 1658 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1659 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1660 request.Method = "DELETE" 1661 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1662 if err != nil { 1663 return out, metadata, &smithy.SerializationError{Err: err} 1664 } 1665 1666 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 1667 return out, metadata, &smithy.SerializationError{Err: err} 1668 } 1669 1670 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1671 return out, metadata, &smithy.SerializationError{Err: err} 1672 } 1673 in.Request = request 1674 1675 return next.HandleSerialize(ctx, in) 1676} 1677func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 1678 if v == nil { 1679 return fmt.Errorf("unsupported serialization of nil %T", v) 1680 } 1681 1682 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1683 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 1684 } 1685 if v.ResourceArn != nil { 1686 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 1687 return err 1688 } 1689 } 1690 1691 if v.TagKeys != nil { 1692 for i := range v.TagKeys { 1693 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 1694 } 1695 } 1696 1697 return nil 1698} 1699 1700type awsRestjson1_serializeOpUpdateDeletionProtection struct { 1701} 1702 1703func (*awsRestjson1_serializeOpUpdateDeletionProtection) ID() string { 1704 return "OperationSerializer" 1705} 1706 1707func (m *awsRestjson1_serializeOpUpdateDeletionProtection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1708 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1709) { 1710 request, ok := in.Request.(*smithyhttp.Request) 1711 if !ok { 1712 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1713 } 1714 1715 input, ok := in.Parameters.(*UpdateDeletionProtectionInput) 1716 _ = input 1717 if !ok { 1718 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1719 } 1720 1721 opPath, opQuery := httpbinding.SplitURI("/updateDeletionProtection") 1722 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1723 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1724 request.Method = "POST" 1725 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1726 if err != nil { 1727 return out, metadata, &smithy.SerializationError{Err: err} 1728 } 1729 1730 restEncoder.SetHeader("Content-Type").String("application/json") 1731 1732 jsonEncoder := smithyjson.NewEncoder() 1733 if err := awsRestjson1_serializeOpDocumentUpdateDeletionProtectionInput(input, jsonEncoder.Value); err != nil { 1734 return out, metadata, &smithy.SerializationError{Err: err} 1735 } 1736 1737 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1738 return out, metadata, &smithy.SerializationError{Err: err} 1739 } 1740 1741 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1742 return out, metadata, &smithy.SerializationError{Err: err} 1743 } 1744 in.Request = request 1745 1746 return next.HandleSerialize(ctx, in) 1747} 1748func awsRestjson1_serializeOpHttpBindingsUpdateDeletionProtectionInput(v *UpdateDeletionProtectionInput, encoder *httpbinding.Encoder) error { 1749 if v == nil { 1750 return fmt.Errorf("unsupported serialization of nil %T", v) 1751 } 1752 1753 return nil 1754} 1755 1756func awsRestjson1_serializeOpDocumentUpdateDeletionProtectionInput(v *UpdateDeletionProtectionInput, value smithyjson.Value) error { 1757 object := value.Object() 1758 defer object.Close() 1759 1760 if v.Arn != nil { 1761 ok := object.Key("arn") 1762 ok.String(*v.Arn) 1763 } 1764 1765 if v.ClientToken != nil { 1766 ok := object.Key("clientToken") 1767 ok.String(*v.ClientToken) 1768 } 1769 1770 if v.DeletionProtected != nil { 1771 ok := object.Key("deletionProtected") 1772 ok.Boolean(*v.DeletionProtected) 1773 } 1774 1775 return nil 1776} 1777 1778type awsRestjson1_serializeOpUpdateIncidentRecord struct { 1779} 1780 1781func (*awsRestjson1_serializeOpUpdateIncidentRecord) ID() string { 1782 return "OperationSerializer" 1783} 1784 1785func (m *awsRestjson1_serializeOpUpdateIncidentRecord) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1786 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1787) { 1788 request, ok := in.Request.(*smithyhttp.Request) 1789 if !ok { 1790 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1791 } 1792 1793 input, ok := in.Parameters.(*UpdateIncidentRecordInput) 1794 _ = input 1795 if !ok { 1796 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1797 } 1798 1799 opPath, opQuery := httpbinding.SplitURI("/updateIncidentRecord") 1800 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1801 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1802 request.Method = "POST" 1803 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1804 if err != nil { 1805 return out, metadata, &smithy.SerializationError{Err: err} 1806 } 1807 1808 restEncoder.SetHeader("Content-Type").String("application/json") 1809 1810 jsonEncoder := smithyjson.NewEncoder() 1811 if err := awsRestjson1_serializeOpDocumentUpdateIncidentRecordInput(input, jsonEncoder.Value); err != nil { 1812 return out, metadata, &smithy.SerializationError{Err: err} 1813 } 1814 1815 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1816 return out, metadata, &smithy.SerializationError{Err: err} 1817 } 1818 1819 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1820 return out, metadata, &smithy.SerializationError{Err: err} 1821 } 1822 in.Request = request 1823 1824 return next.HandleSerialize(ctx, in) 1825} 1826func awsRestjson1_serializeOpHttpBindingsUpdateIncidentRecordInput(v *UpdateIncidentRecordInput, encoder *httpbinding.Encoder) error { 1827 if v == nil { 1828 return fmt.Errorf("unsupported serialization of nil %T", v) 1829 } 1830 1831 return nil 1832} 1833 1834func awsRestjson1_serializeOpDocumentUpdateIncidentRecordInput(v *UpdateIncidentRecordInput, value smithyjson.Value) error { 1835 object := value.Object() 1836 defer object.Close() 1837 1838 if v.Arn != nil { 1839 ok := object.Key("arn") 1840 ok.String(*v.Arn) 1841 } 1842 1843 if v.ChatChannel != nil { 1844 ok := object.Key("chatChannel") 1845 if err := awsRestjson1_serializeDocumentChatChannel(v.ChatChannel, ok); err != nil { 1846 return err 1847 } 1848 } 1849 1850 if v.ClientToken != nil { 1851 ok := object.Key("clientToken") 1852 ok.String(*v.ClientToken) 1853 } 1854 1855 if v.Impact != nil { 1856 ok := object.Key("impact") 1857 ok.Integer(*v.Impact) 1858 } 1859 1860 if v.NotificationTargets != nil { 1861 ok := object.Key("notificationTargets") 1862 if err := awsRestjson1_serializeDocumentNotificationTargetSet(v.NotificationTargets, ok); err != nil { 1863 return err 1864 } 1865 } 1866 1867 if len(v.Status) > 0 { 1868 ok := object.Key("status") 1869 ok.String(string(v.Status)) 1870 } 1871 1872 if v.Summary != nil { 1873 ok := object.Key("summary") 1874 ok.String(*v.Summary) 1875 } 1876 1877 if v.Title != nil { 1878 ok := object.Key("title") 1879 ok.String(*v.Title) 1880 } 1881 1882 return nil 1883} 1884 1885type awsRestjson1_serializeOpUpdateRelatedItems struct { 1886} 1887 1888func (*awsRestjson1_serializeOpUpdateRelatedItems) ID() string { 1889 return "OperationSerializer" 1890} 1891 1892func (m *awsRestjson1_serializeOpUpdateRelatedItems) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1893 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1894) { 1895 request, ok := in.Request.(*smithyhttp.Request) 1896 if !ok { 1897 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1898 } 1899 1900 input, ok := in.Parameters.(*UpdateRelatedItemsInput) 1901 _ = input 1902 if !ok { 1903 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1904 } 1905 1906 opPath, opQuery := httpbinding.SplitURI("/updateRelatedItems") 1907 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1908 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1909 request.Method = "POST" 1910 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1911 if err != nil { 1912 return out, metadata, &smithy.SerializationError{Err: err} 1913 } 1914 1915 restEncoder.SetHeader("Content-Type").String("application/json") 1916 1917 jsonEncoder := smithyjson.NewEncoder() 1918 if err := awsRestjson1_serializeOpDocumentUpdateRelatedItemsInput(input, jsonEncoder.Value); err != nil { 1919 return out, metadata, &smithy.SerializationError{Err: err} 1920 } 1921 1922 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1923 return out, metadata, &smithy.SerializationError{Err: err} 1924 } 1925 1926 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1927 return out, metadata, &smithy.SerializationError{Err: err} 1928 } 1929 in.Request = request 1930 1931 return next.HandleSerialize(ctx, in) 1932} 1933func awsRestjson1_serializeOpHttpBindingsUpdateRelatedItemsInput(v *UpdateRelatedItemsInput, encoder *httpbinding.Encoder) error { 1934 if v == nil { 1935 return fmt.Errorf("unsupported serialization of nil %T", v) 1936 } 1937 1938 return nil 1939} 1940 1941func awsRestjson1_serializeOpDocumentUpdateRelatedItemsInput(v *UpdateRelatedItemsInput, value smithyjson.Value) error { 1942 object := value.Object() 1943 defer object.Close() 1944 1945 if v.ClientToken != nil { 1946 ok := object.Key("clientToken") 1947 ok.String(*v.ClientToken) 1948 } 1949 1950 if v.IncidentRecordArn != nil { 1951 ok := object.Key("incidentRecordArn") 1952 ok.String(*v.IncidentRecordArn) 1953 } 1954 1955 if v.RelatedItemsUpdate != nil { 1956 ok := object.Key("relatedItemsUpdate") 1957 if err := awsRestjson1_serializeDocumentRelatedItemsUpdate(v.RelatedItemsUpdate, ok); err != nil { 1958 return err 1959 } 1960 } 1961 1962 return nil 1963} 1964 1965type awsRestjson1_serializeOpUpdateReplicationSet struct { 1966} 1967 1968func (*awsRestjson1_serializeOpUpdateReplicationSet) ID() string { 1969 return "OperationSerializer" 1970} 1971 1972func (m *awsRestjson1_serializeOpUpdateReplicationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1973 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1974) { 1975 request, ok := in.Request.(*smithyhttp.Request) 1976 if !ok { 1977 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1978 } 1979 1980 input, ok := in.Parameters.(*UpdateReplicationSetInput) 1981 _ = input 1982 if !ok { 1983 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1984 } 1985 1986 opPath, opQuery := httpbinding.SplitURI("/updateReplicationSet") 1987 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1988 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1989 request.Method = "POST" 1990 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1991 if err != nil { 1992 return out, metadata, &smithy.SerializationError{Err: err} 1993 } 1994 1995 restEncoder.SetHeader("Content-Type").String("application/json") 1996 1997 jsonEncoder := smithyjson.NewEncoder() 1998 if err := awsRestjson1_serializeOpDocumentUpdateReplicationSetInput(input, jsonEncoder.Value); err != nil { 1999 return out, metadata, &smithy.SerializationError{Err: err} 2000 } 2001 2002 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2003 return out, metadata, &smithy.SerializationError{Err: err} 2004 } 2005 2006 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2007 return out, metadata, &smithy.SerializationError{Err: err} 2008 } 2009 in.Request = request 2010 2011 return next.HandleSerialize(ctx, in) 2012} 2013func awsRestjson1_serializeOpHttpBindingsUpdateReplicationSetInput(v *UpdateReplicationSetInput, encoder *httpbinding.Encoder) error { 2014 if v == nil { 2015 return fmt.Errorf("unsupported serialization of nil %T", v) 2016 } 2017 2018 return nil 2019} 2020 2021func awsRestjson1_serializeOpDocumentUpdateReplicationSetInput(v *UpdateReplicationSetInput, value smithyjson.Value) error { 2022 object := value.Object() 2023 defer object.Close() 2024 2025 if v.Actions != nil { 2026 ok := object.Key("actions") 2027 if err := awsRestjson1_serializeDocumentUpdateActionList(v.Actions, ok); err != nil { 2028 return err 2029 } 2030 } 2031 2032 if v.Arn != nil { 2033 ok := object.Key("arn") 2034 ok.String(*v.Arn) 2035 } 2036 2037 if v.ClientToken != nil { 2038 ok := object.Key("clientToken") 2039 ok.String(*v.ClientToken) 2040 } 2041 2042 return nil 2043} 2044 2045type awsRestjson1_serializeOpUpdateResponsePlan struct { 2046} 2047 2048func (*awsRestjson1_serializeOpUpdateResponsePlan) ID() string { 2049 return "OperationSerializer" 2050} 2051 2052func (m *awsRestjson1_serializeOpUpdateResponsePlan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2053 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2054) { 2055 request, ok := in.Request.(*smithyhttp.Request) 2056 if !ok { 2057 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2058 } 2059 2060 input, ok := in.Parameters.(*UpdateResponsePlanInput) 2061 _ = input 2062 if !ok { 2063 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2064 } 2065 2066 opPath, opQuery := httpbinding.SplitURI("/updateResponsePlan") 2067 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2068 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2069 request.Method = "POST" 2070 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2071 if err != nil { 2072 return out, metadata, &smithy.SerializationError{Err: err} 2073 } 2074 2075 restEncoder.SetHeader("Content-Type").String("application/json") 2076 2077 jsonEncoder := smithyjson.NewEncoder() 2078 if err := awsRestjson1_serializeOpDocumentUpdateResponsePlanInput(input, jsonEncoder.Value); err != nil { 2079 return out, metadata, &smithy.SerializationError{Err: err} 2080 } 2081 2082 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2083 return out, metadata, &smithy.SerializationError{Err: err} 2084 } 2085 2086 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2087 return out, metadata, &smithy.SerializationError{Err: err} 2088 } 2089 in.Request = request 2090 2091 return next.HandleSerialize(ctx, in) 2092} 2093func awsRestjson1_serializeOpHttpBindingsUpdateResponsePlanInput(v *UpdateResponsePlanInput, encoder *httpbinding.Encoder) error { 2094 if v == nil { 2095 return fmt.Errorf("unsupported serialization of nil %T", v) 2096 } 2097 2098 return nil 2099} 2100 2101func awsRestjson1_serializeOpDocumentUpdateResponsePlanInput(v *UpdateResponsePlanInput, value smithyjson.Value) error { 2102 object := value.Object() 2103 defer object.Close() 2104 2105 if v.Actions != nil { 2106 ok := object.Key("actions") 2107 if err := awsRestjson1_serializeDocumentActionsList(v.Actions, ok); err != nil { 2108 return err 2109 } 2110 } 2111 2112 if v.Arn != nil { 2113 ok := object.Key("arn") 2114 ok.String(*v.Arn) 2115 } 2116 2117 if v.ChatChannel != nil { 2118 ok := object.Key("chatChannel") 2119 if err := awsRestjson1_serializeDocumentChatChannel(v.ChatChannel, ok); err != nil { 2120 return err 2121 } 2122 } 2123 2124 if v.ClientToken != nil { 2125 ok := object.Key("clientToken") 2126 ok.String(*v.ClientToken) 2127 } 2128 2129 if v.DisplayName != nil { 2130 ok := object.Key("displayName") 2131 ok.String(*v.DisplayName) 2132 } 2133 2134 if v.Engagements != nil { 2135 ok := object.Key("engagements") 2136 if err := awsRestjson1_serializeDocumentEngagementSet(v.Engagements, ok); err != nil { 2137 return err 2138 } 2139 } 2140 2141 if v.IncidentTemplateDedupeString != nil { 2142 ok := object.Key("incidentTemplateDedupeString") 2143 ok.String(*v.IncidentTemplateDedupeString) 2144 } 2145 2146 if v.IncidentTemplateImpact != nil { 2147 ok := object.Key("incidentTemplateImpact") 2148 ok.Integer(*v.IncidentTemplateImpact) 2149 } 2150 2151 if v.IncidentTemplateNotificationTargets != nil { 2152 ok := object.Key("incidentTemplateNotificationTargets") 2153 if err := awsRestjson1_serializeDocumentNotificationTargetSet(v.IncidentTemplateNotificationTargets, ok); err != nil { 2154 return err 2155 } 2156 } 2157 2158 if v.IncidentTemplateSummary != nil { 2159 ok := object.Key("incidentTemplateSummary") 2160 ok.String(*v.IncidentTemplateSummary) 2161 } 2162 2163 if v.IncidentTemplateTitle != nil { 2164 ok := object.Key("incidentTemplateTitle") 2165 ok.String(*v.IncidentTemplateTitle) 2166 } 2167 2168 return nil 2169} 2170 2171type awsRestjson1_serializeOpUpdateTimelineEvent struct { 2172} 2173 2174func (*awsRestjson1_serializeOpUpdateTimelineEvent) ID() string { 2175 return "OperationSerializer" 2176} 2177 2178func (m *awsRestjson1_serializeOpUpdateTimelineEvent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2179 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2180) { 2181 request, ok := in.Request.(*smithyhttp.Request) 2182 if !ok { 2183 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2184 } 2185 2186 input, ok := in.Parameters.(*UpdateTimelineEventInput) 2187 _ = input 2188 if !ok { 2189 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2190 } 2191 2192 opPath, opQuery := httpbinding.SplitURI("/updateTimelineEvent") 2193 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2194 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2195 request.Method = "POST" 2196 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2197 if err != nil { 2198 return out, metadata, &smithy.SerializationError{Err: err} 2199 } 2200 2201 restEncoder.SetHeader("Content-Type").String("application/json") 2202 2203 jsonEncoder := smithyjson.NewEncoder() 2204 if err := awsRestjson1_serializeOpDocumentUpdateTimelineEventInput(input, jsonEncoder.Value); err != nil { 2205 return out, metadata, &smithy.SerializationError{Err: err} 2206 } 2207 2208 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2209 return out, metadata, &smithy.SerializationError{Err: err} 2210 } 2211 2212 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2213 return out, metadata, &smithy.SerializationError{Err: err} 2214 } 2215 in.Request = request 2216 2217 return next.HandleSerialize(ctx, in) 2218} 2219func awsRestjson1_serializeOpHttpBindingsUpdateTimelineEventInput(v *UpdateTimelineEventInput, encoder *httpbinding.Encoder) error { 2220 if v == nil { 2221 return fmt.Errorf("unsupported serialization of nil %T", v) 2222 } 2223 2224 return nil 2225} 2226 2227func awsRestjson1_serializeOpDocumentUpdateTimelineEventInput(v *UpdateTimelineEventInput, value smithyjson.Value) error { 2228 object := value.Object() 2229 defer object.Close() 2230 2231 if v.ClientToken != nil { 2232 ok := object.Key("clientToken") 2233 ok.String(*v.ClientToken) 2234 } 2235 2236 if v.EventData != nil { 2237 ok := object.Key("eventData") 2238 ok.String(*v.EventData) 2239 } 2240 2241 if v.EventId != nil { 2242 ok := object.Key("eventId") 2243 ok.String(*v.EventId) 2244 } 2245 2246 if v.EventTime != nil { 2247 ok := object.Key("eventTime") 2248 ok.Double(smithytime.FormatEpochSeconds(*v.EventTime)) 2249 } 2250 2251 if v.EventType != nil { 2252 ok := object.Key("eventType") 2253 ok.String(*v.EventType) 2254 } 2255 2256 if v.IncidentRecordArn != nil { 2257 ok := object.Key("incidentRecordArn") 2258 ok.String(*v.IncidentRecordArn) 2259 } 2260 2261 return nil 2262} 2263 2264func awsRestjson1_serializeDocumentAction(v types.Action, value smithyjson.Value) error { 2265 object := value.Object() 2266 defer object.Close() 2267 2268 switch uv := v.(type) { 2269 case *types.ActionMemberSsmAutomation: 2270 av := object.Key("ssmAutomation") 2271 if err := awsRestjson1_serializeDocumentSsmAutomation(&uv.Value, av); err != nil { 2272 return err 2273 } 2274 2275 default: 2276 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 2277 2278 } 2279 return nil 2280} 2281 2282func awsRestjson1_serializeDocumentActionsList(v []types.Action, value smithyjson.Value) error { 2283 array := value.Array() 2284 defer array.Close() 2285 2286 for i := range v { 2287 av := array.Value() 2288 if vv := v[i]; vv == nil { 2289 continue 2290 } 2291 if err := awsRestjson1_serializeDocumentAction(v[i], av); err != nil { 2292 return err 2293 } 2294 } 2295 return nil 2296} 2297 2298func awsRestjson1_serializeDocumentAddRegionAction(v *types.AddRegionAction, value smithyjson.Value) error { 2299 object := value.Object() 2300 defer object.Close() 2301 2302 if v.RegionName != nil { 2303 ok := object.Key("regionName") 2304 ok.String(*v.RegionName) 2305 } 2306 2307 if v.SseKmsKeyId != nil { 2308 ok := object.Key("sseKmsKeyId") 2309 ok.String(*v.SseKmsKeyId) 2310 } 2311 2312 return nil 2313} 2314 2315func awsRestjson1_serializeDocumentAttributeValueList(v types.AttributeValueList, value smithyjson.Value) error { 2316 object := value.Object() 2317 defer object.Close() 2318 2319 switch uv := v.(type) { 2320 case *types.AttributeValueListMemberIntegerValues: 2321 av := object.Key("integerValues") 2322 if err := awsRestjson1_serializeDocumentIntegerList(uv.Value, av); err != nil { 2323 return err 2324 } 2325 2326 case *types.AttributeValueListMemberStringValues: 2327 av := object.Key("stringValues") 2328 if err := awsRestjson1_serializeDocumentStringList(uv.Value, av); err != nil { 2329 return err 2330 } 2331 2332 default: 2333 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 2334 2335 } 2336 return nil 2337} 2338 2339func awsRestjson1_serializeDocumentChatbotSnsConfigurationSet(v []string, value smithyjson.Value) error { 2340 array := value.Array() 2341 defer array.Close() 2342 2343 for i := range v { 2344 av := array.Value() 2345 av.String(v[i]) 2346 } 2347 return nil 2348} 2349 2350func awsRestjson1_serializeDocumentChatChannel(v types.ChatChannel, value smithyjson.Value) error { 2351 object := value.Object() 2352 defer object.Close() 2353 2354 switch uv := v.(type) { 2355 case *types.ChatChannelMemberChatbotSns: 2356 av := object.Key("chatbotSns") 2357 if err := awsRestjson1_serializeDocumentChatbotSnsConfigurationSet(uv.Value, av); err != nil { 2358 return err 2359 } 2360 2361 case *types.ChatChannelMemberEmpty: 2362 av := object.Key("empty") 2363 if err := awsRestjson1_serializeDocumentEmptyChatChannel(&uv.Value, av); err != nil { 2364 return err 2365 } 2366 2367 default: 2368 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 2369 2370 } 2371 return nil 2372} 2373 2374func awsRestjson1_serializeDocumentCondition(v types.Condition, value smithyjson.Value) error { 2375 object := value.Object() 2376 defer object.Close() 2377 2378 switch uv := v.(type) { 2379 case *types.ConditionMemberAfter: 2380 av := object.Key("after") 2381 av.Double(smithytime.FormatEpochSeconds(uv.Value)) 2382 2383 case *types.ConditionMemberBefore: 2384 av := object.Key("before") 2385 av.Double(smithytime.FormatEpochSeconds(uv.Value)) 2386 2387 case *types.ConditionMemberEquals: 2388 av := object.Key("equals") 2389 if err := awsRestjson1_serializeDocumentAttributeValueList(uv.Value, av); err != nil { 2390 return err 2391 } 2392 2393 default: 2394 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 2395 2396 } 2397 return nil 2398} 2399 2400func awsRestjson1_serializeDocumentDeleteRegionAction(v *types.DeleteRegionAction, value smithyjson.Value) error { 2401 object := value.Object() 2402 defer object.Close() 2403 2404 if v.RegionName != nil { 2405 ok := object.Key("regionName") 2406 ok.String(*v.RegionName) 2407 } 2408 2409 return nil 2410} 2411 2412func awsRestjson1_serializeDocumentEmptyChatChannel(v *types.EmptyChatChannel, value smithyjson.Value) error { 2413 object := value.Object() 2414 defer object.Close() 2415 2416 return nil 2417} 2418 2419func awsRestjson1_serializeDocumentEngagementSet(v []string, value smithyjson.Value) error { 2420 array := value.Array() 2421 defer array.Close() 2422 2423 for i := range v { 2424 av := array.Value() 2425 av.String(v[i]) 2426 } 2427 return nil 2428} 2429 2430func awsRestjson1_serializeDocumentFilter(v *types.Filter, value smithyjson.Value) error { 2431 object := value.Object() 2432 defer object.Close() 2433 2434 if v.Condition != nil { 2435 ok := object.Key("condition") 2436 if err := awsRestjson1_serializeDocumentCondition(v.Condition, ok); err != nil { 2437 return err 2438 } 2439 } 2440 2441 if v.Key != nil { 2442 ok := object.Key("key") 2443 ok.String(*v.Key) 2444 } 2445 2446 return nil 2447} 2448 2449func awsRestjson1_serializeDocumentFilterList(v []types.Filter, value smithyjson.Value) error { 2450 array := value.Array() 2451 defer array.Close() 2452 2453 for i := range v { 2454 av := array.Value() 2455 if err := awsRestjson1_serializeDocumentFilter(&v[i], av); err != nil { 2456 return err 2457 } 2458 } 2459 return nil 2460} 2461 2462func awsRestjson1_serializeDocumentIncidentTemplate(v *types.IncidentTemplate, value smithyjson.Value) error { 2463 object := value.Object() 2464 defer object.Close() 2465 2466 if v.DedupeString != nil { 2467 ok := object.Key("dedupeString") 2468 ok.String(*v.DedupeString) 2469 } 2470 2471 if v.Impact != nil { 2472 ok := object.Key("impact") 2473 ok.Integer(*v.Impact) 2474 } 2475 2476 if v.NotificationTargets != nil { 2477 ok := object.Key("notificationTargets") 2478 if err := awsRestjson1_serializeDocumentNotificationTargetSet(v.NotificationTargets, ok); err != nil { 2479 return err 2480 } 2481 } 2482 2483 if v.Summary != nil { 2484 ok := object.Key("summary") 2485 ok.String(*v.Summary) 2486 } 2487 2488 if v.Title != nil { 2489 ok := object.Key("title") 2490 ok.String(*v.Title) 2491 } 2492 2493 return nil 2494} 2495 2496func awsRestjson1_serializeDocumentIntegerList(v []int32, value smithyjson.Value) error { 2497 array := value.Array() 2498 defer array.Close() 2499 2500 for i := range v { 2501 av := array.Value() 2502 av.Integer(v[i]) 2503 } 2504 return nil 2505} 2506 2507func awsRestjson1_serializeDocumentItemIdentifier(v *types.ItemIdentifier, value smithyjson.Value) error { 2508 object := value.Object() 2509 defer object.Close() 2510 2511 if len(v.Type) > 0 { 2512 ok := object.Key("type") 2513 ok.String(string(v.Type)) 2514 } 2515 2516 if v.Value != nil { 2517 ok := object.Key("value") 2518 if err := awsRestjson1_serializeDocumentItemValue(v.Value, ok); err != nil { 2519 return err 2520 } 2521 } 2522 2523 return nil 2524} 2525 2526func awsRestjson1_serializeDocumentItemValue(v types.ItemValue, value smithyjson.Value) error { 2527 object := value.Object() 2528 defer object.Close() 2529 2530 switch uv := v.(type) { 2531 case *types.ItemValueMemberArn: 2532 av := object.Key("arn") 2533 av.String(uv.Value) 2534 2535 case *types.ItemValueMemberMetricDefinition: 2536 av := object.Key("metricDefinition") 2537 av.String(uv.Value) 2538 2539 case *types.ItemValueMemberUrl: 2540 av := object.Key("url") 2541 av.String(uv.Value) 2542 2543 default: 2544 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 2545 2546 } 2547 return nil 2548} 2549 2550func awsRestjson1_serializeDocumentNotificationTargetItem(v types.NotificationTargetItem, value smithyjson.Value) error { 2551 object := value.Object() 2552 defer object.Close() 2553 2554 switch uv := v.(type) { 2555 case *types.NotificationTargetItemMemberSnsTopicArn: 2556 av := object.Key("snsTopicArn") 2557 av.String(uv.Value) 2558 2559 default: 2560 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 2561 2562 } 2563 return nil 2564} 2565 2566func awsRestjson1_serializeDocumentNotificationTargetSet(v []types.NotificationTargetItem, value smithyjson.Value) error { 2567 array := value.Array() 2568 defer array.Close() 2569 2570 for i := range v { 2571 av := array.Value() 2572 if vv := v[i]; vv == nil { 2573 continue 2574 } 2575 if err := awsRestjson1_serializeDocumentNotificationTargetItem(v[i], av); err != nil { 2576 return err 2577 } 2578 } 2579 return nil 2580} 2581 2582func awsRestjson1_serializeDocumentRegionMapInput(v map[string]types.RegionMapInputValue, value smithyjson.Value) error { 2583 object := value.Object() 2584 defer object.Close() 2585 2586 for key := range v { 2587 om := object.Key(key) 2588 mapVar := v[key] 2589 if err := awsRestjson1_serializeDocumentRegionMapInputValue(&mapVar, om); err != nil { 2590 return err 2591 } 2592 } 2593 return nil 2594} 2595 2596func awsRestjson1_serializeDocumentRegionMapInputValue(v *types.RegionMapInputValue, value smithyjson.Value) error { 2597 object := value.Object() 2598 defer object.Close() 2599 2600 if v.SseKmsKeyId != nil { 2601 ok := object.Key("sseKmsKeyId") 2602 ok.String(*v.SseKmsKeyId) 2603 } 2604 2605 return nil 2606} 2607 2608func awsRestjson1_serializeDocumentRelatedItem(v *types.RelatedItem, value smithyjson.Value) error { 2609 object := value.Object() 2610 defer object.Close() 2611 2612 if v.Identifier != nil { 2613 ok := object.Key("identifier") 2614 if err := awsRestjson1_serializeDocumentItemIdentifier(v.Identifier, ok); err != nil { 2615 return err 2616 } 2617 } 2618 2619 if v.Title != nil { 2620 ok := object.Key("title") 2621 ok.String(*v.Title) 2622 } 2623 2624 return nil 2625} 2626 2627func awsRestjson1_serializeDocumentRelatedItemList(v []types.RelatedItem, value smithyjson.Value) error { 2628 array := value.Array() 2629 defer array.Close() 2630 2631 for i := range v { 2632 av := array.Value() 2633 if err := awsRestjson1_serializeDocumentRelatedItem(&v[i], av); err != nil { 2634 return err 2635 } 2636 } 2637 return nil 2638} 2639 2640func awsRestjson1_serializeDocumentRelatedItemsUpdate(v types.RelatedItemsUpdate, value smithyjson.Value) error { 2641 object := value.Object() 2642 defer object.Close() 2643 2644 switch uv := v.(type) { 2645 case *types.RelatedItemsUpdateMemberItemToAdd: 2646 av := object.Key("itemToAdd") 2647 if err := awsRestjson1_serializeDocumentRelatedItem(&uv.Value, av); err != nil { 2648 return err 2649 } 2650 2651 case *types.RelatedItemsUpdateMemberItemToRemove: 2652 av := object.Key("itemToRemove") 2653 if err := awsRestjson1_serializeDocumentItemIdentifier(&uv.Value, av); err != nil { 2654 return err 2655 } 2656 2657 default: 2658 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 2659 2660 } 2661 return nil 2662} 2663 2664func awsRestjson1_serializeDocumentSsmAutomation(v *types.SsmAutomation, value smithyjson.Value) error { 2665 object := value.Object() 2666 defer object.Close() 2667 2668 if v.DocumentName != nil { 2669 ok := object.Key("documentName") 2670 ok.String(*v.DocumentName) 2671 } 2672 2673 if v.DocumentVersion != nil { 2674 ok := object.Key("documentVersion") 2675 ok.String(*v.DocumentVersion) 2676 } 2677 2678 if v.Parameters != nil { 2679 ok := object.Key("parameters") 2680 if err := awsRestjson1_serializeDocumentSsmParameters(v.Parameters, ok); err != nil { 2681 return err 2682 } 2683 } 2684 2685 if v.RoleArn != nil { 2686 ok := object.Key("roleArn") 2687 ok.String(*v.RoleArn) 2688 } 2689 2690 if len(v.TargetAccount) > 0 { 2691 ok := object.Key("targetAccount") 2692 ok.String(string(v.TargetAccount)) 2693 } 2694 2695 return nil 2696} 2697 2698func awsRestjson1_serializeDocumentSsmParameters(v map[string][]string, value smithyjson.Value) error { 2699 object := value.Object() 2700 defer object.Close() 2701 2702 for key := range v { 2703 om := object.Key(key) 2704 if vv := v[key]; vv == nil { 2705 continue 2706 } 2707 if err := awsRestjson1_serializeDocumentSsmParameterValues(v[key], om); err != nil { 2708 return err 2709 } 2710 } 2711 return nil 2712} 2713 2714func awsRestjson1_serializeDocumentSsmParameterValues(v []string, value smithyjson.Value) error { 2715 array := value.Array() 2716 defer array.Close() 2717 2718 for i := range v { 2719 av := array.Value() 2720 av.String(v[i]) 2721 } 2722 return nil 2723} 2724 2725func awsRestjson1_serializeDocumentStringList(v []string, value smithyjson.Value) error { 2726 array := value.Array() 2727 defer array.Close() 2728 2729 for i := range v { 2730 av := array.Value() 2731 av.String(v[i]) 2732 } 2733 return nil 2734} 2735 2736func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 2737 object := value.Object() 2738 defer object.Close() 2739 2740 for key := range v { 2741 om := object.Key(key) 2742 om.String(v[key]) 2743 } 2744 return nil 2745} 2746 2747func awsRestjson1_serializeDocumentTriggerDetails(v *types.TriggerDetails, value smithyjson.Value) error { 2748 object := value.Object() 2749 defer object.Close() 2750 2751 if v.RawData != nil { 2752 ok := object.Key("rawData") 2753 ok.String(*v.RawData) 2754 } 2755 2756 if v.Source != nil { 2757 ok := object.Key("source") 2758 ok.String(*v.Source) 2759 } 2760 2761 if v.Timestamp != nil { 2762 ok := object.Key("timestamp") 2763 ok.Double(smithytime.FormatEpochSeconds(*v.Timestamp)) 2764 } 2765 2766 if v.TriggerArn != nil { 2767 ok := object.Key("triggerArn") 2768 ok.String(*v.TriggerArn) 2769 } 2770 2771 return nil 2772} 2773 2774func awsRestjson1_serializeDocumentUpdateActionList(v []types.UpdateReplicationSetAction, value smithyjson.Value) error { 2775 array := value.Array() 2776 defer array.Close() 2777 2778 for i := range v { 2779 av := array.Value() 2780 if vv := v[i]; vv == nil { 2781 continue 2782 } 2783 if err := awsRestjson1_serializeDocumentUpdateReplicationSetAction(v[i], av); err != nil { 2784 return err 2785 } 2786 } 2787 return nil 2788} 2789 2790func awsRestjson1_serializeDocumentUpdateReplicationSetAction(v types.UpdateReplicationSetAction, value smithyjson.Value) error { 2791 object := value.Object() 2792 defer object.Close() 2793 2794 switch uv := v.(type) { 2795 case *types.UpdateReplicationSetActionMemberAddRegionAction: 2796 av := object.Key("addRegionAction") 2797 if err := awsRestjson1_serializeDocumentAddRegionAction(&uv.Value, av); err != nil { 2798 return err 2799 } 2800 2801 case *types.UpdateReplicationSetActionMemberDeleteRegionAction: 2802 av := object.Key("deleteRegionAction") 2803 if err := awsRestjson1_serializeDocumentDeleteRegionAction(&uv.Value, av); err != nil { 2804 return err 2805 } 2806 2807 default: 2808 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 2809 2810 } 2811 return nil 2812} 2813