1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package devopsguru 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/devopsguru/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_serializeOpAddNotificationChannel struct { 19} 20 21func (*awsRestjson1_serializeOpAddNotificationChannel) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpAddNotificationChannel) 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.(*AddNotificationChannelInput) 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("/channels") 40 request.URL.Path = opPath 41 if len(request.URL.RawQuery) > 0 { 42 request.URL.RawQuery = "&" + opQuery 43 } else { 44 request.URL.RawQuery = opQuery 45 } 46 47 request.Method = "PUT" 48 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 49 if err != nil { 50 return out, metadata, &smithy.SerializationError{Err: err} 51 } 52 53 restEncoder.SetHeader("Content-Type").String("application/json") 54 55 jsonEncoder := smithyjson.NewEncoder() 56 if err := awsRestjson1_serializeOpDocumentAddNotificationChannelInput(input, jsonEncoder.Value); err != nil { 57 return out, metadata, &smithy.SerializationError{Err: err} 58 } 59 60 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 61 return out, metadata, &smithy.SerializationError{Err: err} 62 } 63 64 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 65 return out, metadata, &smithy.SerializationError{Err: err} 66 } 67 in.Request = request 68 69 return next.HandleSerialize(ctx, in) 70} 71func awsRestjson1_serializeOpHttpBindingsAddNotificationChannelInput(v *AddNotificationChannelInput, encoder *httpbinding.Encoder) error { 72 if v == nil { 73 return fmt.Errorf("unsupported serialization of nil %T", v) 74 } 75 76 return nil 77} 78 79func awsRestjson1_serializeOpDocumentAddNotificationChannelInput(v *AddNotificationChannelInput, value smithyjson.Value) error { 80 object := value.Object() 81 defer object.Close() 82 83 if v.Config != nil { 84 ok := object.Key("Config") 85 if err := awsRestjson1_serializeDocumentNotificationChannelConfig(v.Config, ok); err != nil { 86 return err 87 } 88 } 89 90 return nil 91} 92 93type awsRestjson1_serializeOpDescribeAccountHealth struct { 94} 95 96func (*awsRestjson1_serializeOpDescribeAccountHealth) ID() string { 97 return "OperationSerializer" 98} 99 100func (m *awsRestjson1_serializeOpDescribeAccountHealth) 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.(*DescribeAccountHealthInput) 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("/accounts/health") 115 request.URL.Path = opPath 116 if len(request.URL.RawQuery) > 0 { 117 request.URL.RawQuery = "&" + opQuery 118 } else { 119 request.URL.RawQuery = opQuery 120 } 121 122 request.Method = "GET" 123 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 124 if err != nil { 125 return out, metadata, &smithy.SerializationError{Err: err} 126 } 127 128 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 129 return out, metadata, &smithy.SerializationError{Err: err} 130 } 131 in.Request = request 132 133 return next.HandleSerialize(ctx, in) 134} 135func awsRestjson1_serializeOpHttpBindingsDescribeAccountHealthInput(v *DescribeAccountHealthInput, encoder *httpbinding.Encoder) error { 136 if v == nil { 137 return fmt.Errorf("unsupported serialization of nil %T", v) 138 } 139 140 return nil 141} 142 143type awsRestjson1_serializeOpDescribeAccountOverview struct { 144} 145 146func (*awsRestjson1_serializeOpDescribeAccountOverview) ID() string { 147 return "OperationSerializer" 148} 149 150func (m *awsRestjson1_serializeOpDescribeAccountOverview) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 151 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 152) { 153 request, ok := in.Request.(*smithyhttp.Request) 154 if !ok { 155 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 156 } 157 158 input, ok := in.Parameters.(*DescribeAccountOverviewInput) 159 _ = input 160 if !ok { 161 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 162 } 163 164 opPath, opQuery := httpbinding.SplitURI("/accounts/overview") 165 request.URL.Path = opPath 166 if len(request.URL.RawQuery) > 0 { 167 request.URL.RawQuery = "&" + opQuery 168 } else { 169 request.URL.RawQuery = opQuery 170 } 171 172 request.Method = "POST" 173 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 174 if err != nil { 175 return out, metadata, &smithy.SerializationError{Err: err} 176 } 177 178 restEncoder.SetHeader("Content-Type").String("application/json") 179 180 jsonEncoder := smithyjson.NewEncoder() 181 if err := awsRestjson1_serializeOpDocumentDescribeAccountOverviewInput(input, jsonEncoder.Value); err != nil { 182 return out, metadata, &smithy.SerializationError{Err: err} 183 } 184 185 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 186 return out, metadata, &smithy.SerializationError{Err: err} 187 } 188 189 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 190 return out, metadata, &smithy.SerializationError{Err: err} 191 } 192 in.Request = request 193 194 return next.HandleSerialize(ctx, in) 195} 196func awsRestjson1_serializeOpHttpBindingsDescribeAccountOverviewInput(v *DescribeAccountOverviewInput, encoder *httpbinding.Encoder) error { 197 if v == nil { 198 return fmt.Errorf("unsupported serialization of nil %T", v) 199 } 200 201 return nil 202} 203 204func awsRestjson1_serializeOpDocumentDescribeAccountOverviewInput(v *DescribeAccountOverviewInput, value smithyjson.Value) error { 205 object := value.Object() 206 defer object.Close() 207 208 if v.FromTime != nil { 209 ok := object.Key("FromTime") 210 ok.Double(smithytime.FormatEpochSeconds(*v.FromTime)) 211 } 212 213 if v.ToTime != nil { 214 ok := object.Key("ToTime") 215 ok.Double(smithytime.FormatEpochSeconds(*v.ToTime)) 216 } 217 218 return nil 219} 220 221type awsRestjson1_serializeOpDescribeAnomaly struct { 222} 223 224func (*awsRestjson1_serializeOpDescribeAnomaly) ID() string { 225 return "OperationSerializer" 226} 227 228func (m *awsRestjson1_serializeOpDescribeAnomaly) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 229 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 230) { 231 request, ok := in.Request.(*smithyhttp.Request) 232 if !ok { 233 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 234 } 235 236 input, ok := in.Parameters.(*DescribeAnomalyInput) 237 _ = input 238 if !ok { 239 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 240 } 241 242 opPath, opQuery := httpbinding.SplitURI("/anomalies/{Id}") 243 request.URL.Path = opPath 244 if len(request.URL.RawQuery) > 0 { 245 request.URL.RawQuery = "&" + opQuery 246 } else { 247 request.URL.RawQuery = opQuery 248 } 249 250 request.Method = "GET" 251 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 252 if err != nil { 253 return out, metadata, &smithy.SerializationError{Err: err} 254 } 255 256 if err := awsRestjson1_serializeOpHttpBindingsDescribeAnomalyInput(input, restEncoder); err != nil { 257 return out, metadata, &smithy.SerializationError{Err: err} 258 } 259 260 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 261 return out, metadata, &smithy.SerializationError{Err: err} 262 } 263 in.Request = request 264 265 return next.HandleSerialize(ctx, in) 266} 267func awsRestjson1_serializeOpHttpBindingsDescribeAnomalyInput(v *DescribeAnomalyInput, encoder *httpbinding.Encoder) error { 268 if v == nil { 269 return fmt.Errorf("unsupported serialization of nil %T", v) 270 } 271 272 if v.Id == nil || len(*v.Id) == 0 { 273 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 274 } 275 if v.Id != nil { 276 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 277 return err 278 } 279 } 280 281 return nil 282} 283 284type awsRestjson1_serializeOpDescribeInsight struct { 285} 286 287func (*awsRestjson1_serializeOpDescribeInsight) ID() string { 288 return "OperationSerializer" 289} 290 291func (m *awsRestjson1_serializeOpDescribeInsight) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 292 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 293) { 294 request, ok := in.Request.(*smithyhttp.Request) 295 if !ok { 296 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 297 } 298 299 input, ok := in.Parameters.(*DescribeInsightInput) 300 _ = input 301 if !ok { 302 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 303 } 304 305 opPath, opQuery := httpbinding.SplitURI("/insights/{Id}") 306 request.URL.Path = opPath 307 if len(request.URL.RawQuery) > 0 { 308 request.URL.RawQuery = "&" + opQuery 309 } else { 310 request.URL.RawQuery = opQuery 311 } 312 313 request.Method = "GET" 314 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 315 if err != nil { 316 return out, metadata, &smithy.SerializationError{Err: err} 317 } 318 319 if err := awsRestjson1_serializeOpHttpBindingsDescribeInsightInput(input, restEncoder); err != nil { 320 return out, metadata, &smithy.SerializationError{Err: err} 321 } 322 323 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 324 return out, metadata, &smithy.SerializationError{Err: err} 325 } 326 in.Request = request 327 328 return next.HandleSerialize(ctx, in) 329} 330func awsRestjson1_serializeOpHttpBindingsDescribeInsightInput(v *DescribeInsightInput, encoder *httpbinding.Encoder) error { 331 if v == nil { 332 return fmt.Errorf("unsupported serialization of nil %T", v) 333 } 334 335 if v.Id == nil || len(*v.Id) == 0 { 336 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 337 } 338 if v.Id != nil { 339 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 340 return err 341 } 342 } 343 344 return nil 345} 346 347type awsRestjson1_serializeOpDescribeResourceCollectionHealth struct { 348} 349 350func (*awsRestjson1_serializeOpDescribeResourceCollectionHealth) ID() string { 351 return "OperationSerializer" 352} 353 354func (m *awsRestjson1_serializeOpDescribeResourceCollectionHealth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 355 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 356) { 357 request, ok := in.Request.(*smithyhttp.Request) 358 if !ok { 359 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 360 } 361 362 input, ok := in.Parameters.(*DescribeResourceCollectionHealthInput) 363 _ = input 364 if !ok { 365 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 366 } 367 368 opPath, opQuery := httpbinding.SplitURI("/accounts/health/resource-collection/{ResourceCollectionType}") 369 request.URL.Path = opPath 370 if len(request.URL.RawQuery) > 0 { 371 request.URL.RawQuery = "&" + opQuery 372 } else { 373 request.URL.RawQuery = opQuery 374 } 375 376 request.Method = "GET" 377 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 378 if err != nil { 379 return out, metadata, &smithy.SerializationError{Err: err} 380 } 381 382 if err := awsRestjson1_serializeOpHttpBindingsDescribeResourceCollectionHealthInput(input, restEncoder); err != nil { 383 return out, metadata, &smithy.SerializationError{Err: err} 384 } 385 386 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 387 return out, metadata, &smithy.SerializationError{Err: err} 388 } 389 in.Request = request 390 391 return next.HandleSerialize(ctx, in) 392} 393func awsRestjson1_serializeOpHttpBindingsDescribeResourceCollectionHealthInput(v *DescribeResourceCollectionHealthInput, encoder *httpbinding.Encoder) error { 394 if v == nil { 395 return fmt.Errorf("unsupported serialization of nil %T", v) 396 } 397 398 if v.NextToken != nil { 399 encoder.SetQuery("NextToken").String(*v.NextToken) 400 } 401 402 if len(v.ResourceCollectionType) == 0 { 403 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceCollectionType must not be empty")} 404 } 405 if len(v.ResourceCollectionType) > 0 { 406 if err := encoder.SetURI("ResourceCollectionType").String(string(v.ResourceCollectionType)); err != nil { 407 return err 408 } 409 } 410 411 return nil 412} 413 414type awsRestjson1_serializeOpDescribeServiceIntegration struct { 415} 416 417func (*awsRestjson1_serializeOpDescribeServiceIntegration) ID() string { 418 return "OperationSerializer" 419} 420 421func (m *awsRestjson1_serializeOpDescribeServiceIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 422 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 423) { 424 request, ok := in.Request.(*smithyhttp.Request) 425 if !ok { 426 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 427 } 428 429 input, ok := in.Parameters.(*DescribeServiceIntegrationInput) 430 _ = input 431 if !ok { 432 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 433 } 434 435 opPath, opQuery := httpbinding.SplitURI("/service-integrations") 436 request.URL.Path = opPath 437 if len(request.URL.RawQuery) > 0 { 438 request.URL.RawQuery = "&" + opQuery 439 } else { 440 request.URL.RawQuery = opQuery 441 } 442 443 request.Method = "GET" 444 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 445 if err != nil { 446 return out, metadata, &smithy.SerializationError{Err: err} 447 } 448 449 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 450 return out, metadata, &smithy.SerializationError{Err: err} 451 } 452 in.Request = request 453 454 return next.HandleSerialize(ctx, in) 455} 456func awsRestjson1_serializeOpHttpBindingsDescribeServiceIntegrationInput(v *DescribeServiceIntegrationInput, encoder *httpbinding.Encoder) error { 457 if v == nil { 458 return fmt.Errorf("unsupported serialization of nil %T", v) 459 } 460 461 return nil 462} 463 464type awsRestjson1_serializeOpGetResourceCollection struct { 465} 466 467func (*awsRestjson1_serializeOpGetResourceCollection) ID() string { 468 return "OperationSerializer" 469} 470 471func (m *awsRestjson1_serializeOpGetResourceCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 472 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 473) { 474 request, ok := in.Request.(*smithyhttp.Request) 475 if !ok { 476 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 477 } 478 479 input, ok := in.Parameters.(*GetResourceCollectionInput) 480 _ = input 481 if !ok { 482 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 483 } 484 485 opPath, opQuery := httpbinding.SplitURI("/resource-collections/{ResourceCollectionType}") 486 request.URL.Path = opPath 487 if len(request.URL.RawQuery) > 0 { 488 request.URL.RawQuery = "&" + opQuery 489 } else { 490 request.URL.RawQuery = opQuery 491 } 492 493 request.Method = "GET" 494 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 495 if err != nil { 496 return out, metadata, &smithy.SerializationError{Err: err} 497 } 498 499 if err := awsRestjson1_serializeOpHttpBindingsGetResourceCollectionInput(input, restEncoder); err != nil { 500 return out, metadata, &smithy.SerializationError{Err: err} 501 } 502 503 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 504 return out, metadata, &smithy.SerializationError{Err: err} 505 } 506 in.Request = request 507 508 return next.HandleSerialize(ctx, in) 509} 510func awsRestjson1_serializeOpHttpBindingsGetResourceCollectionInput(v *GetResourceCollectionInput, encoder *httpbinding.Encoder) error { 511 if v == nil { 512 return fmt.Errorf("unsupported serialization of nil %T", v) 513 } 514 515 if v.NextToken != nil { 516 encoder.SetQuery("NextToken").String(*v.NextToken) 517 } 518 519 if len(v.ResourceCollectionType) == 0 { 520 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceCollectionType must not be empty")} 521 } 522 if len(v.ResourceCollectionType) > 0 { 523 if err := encoder.SetURI("ResourceCollectionType").String(string(v.ResourceCollectionType)); err != nil { 524 return err 525 } 526 } 527 528 return nil 529} 530 531type awsRestjson1_serializeOpListAnomaliesForInsight struct { 532} 533 534func (*awsRestjson1_serializeOpListAnomaliesForInsight) ID() string { 535 return "OperationSerializer" 536} 537 538func (m *awsRestjson1_serializeOpListAnomaliesForInsight) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 539 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 540) { 541 request, ok := in.Request.(*smithyhttp.Request) 542 if !ok { 543 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 544 } 545 546 input, ok := in.Parameters.(*ListAnomaliesForInsightInput) 547 _ = input 548 if !ok { 549 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 550 } 551 552 opPath, opQuery := httpbinding.SplitURI("/anomalies/insight/{InsightId}") 553 request.URL.Path = opPath 554 if len(request.URL.RawQuery) > 0 { 555 request.URL.RawQuery = "&" + opQuery 556 } else { 557 request.URL.RawQuery = opQuery 558 } 559 560 request.Method = "POST" 561 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 562 if err != nil { 563 return out, metadata, &smithy.SerializationError{Err: err} 564 } 565 566 if err := awsRestjson1_serializeOpHttpBindingsListAnomaliesForInsightInput(input, restEncoder); err != nil { 567 return out, metadata, &smithy.SerializationError{Err: err} 568 } 569 570 restEncoder.SetHeader("Content-Type").String("application/json") 571 572 jsonEncoder := smithyjson.NewEncoder() 573 if err := awsRestjson1_serializeOpDocumentListAnomaliesForInsightInput(input, jsonEncoder.Value); err != nil { 574 return out, metadata, &smithy.SerializationError{Err: err} 575 } 576 577 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 578 return out, metadata, &smithy.SerializationError{Err: err} 579 } 580 581 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 582 return out, metadata, &smithy.SerializationError{Err: err} 583 } 584 in.Request = request 585 586 return next.HandleSerialize(ctx, in) 587} 588func awsRestjson1_serializeOpHttpBindingsListAnomaliesForInsightInput(v *ListAnomaliesForInsightInput, encoder *httpbinding.Encoder) error { 589 if v == nil { 590 return fmt.Errorf("unsupported serialization of nil %T", v) 591 } 592 593 if v.InsightId == nil || len(*v.InsightId) == 0 { 594 return &smithy.SerializationError{Err: fmt.Errorf("input member InsightId must not be empty")} 595 } 596 if v.InsightId != nil { 597 if err := encoder.SetURI("InsightId").String(*v.InsightId); err != nil { 598 return err 599 } 600 } 601 602 return nil 603} 604 605func awsRestjson1_serializeOpDocumentListAnomaliesForInsightInput(v *ListAnomaliesForInsightInput, value smithyjson.Value) error { 606 object := value.Object() 607 defer object.Close() 608 609 if v.MaxResults != nil { 610 ok := object.Key("MaxResults") 611 ok.Integer(*v.MaxResults) 612 } 613 614 if v.NextToken != nil { 615 ok := object.Key("NextToken") 616 ok.String(*v.NextToken) 617 } 618 619 if v.StartTimeRange != nil { 620 ok := object.Key("StartTimeRange") 621 if err := awsRestjson1_serializeDocumentStartTimeRange(v.StartTimeRange, ok); err != nil { 622 return err 623 } 624 } 625 626 return nil 627} 628 629type awsRestjson1_serializeOpListEvents struct { 630} 631 632func (*awsRestjson1_serializeOpListEvents) ID() string { 633 return "OperationSerializer" 634} 635 636func (m *awsRestjson1_serializeOpListEvents) 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.(*ListEventsInput) 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("/events") 651 request.URL.Path = opPath 652 if len(request.URL.RawQuery) > 0 { 653 request.URL.RawQuery = "&" + opQuery 654 } else { 655 request.URL.RawQuery = opQuery 656 } 657 658 request.Method = "POST" 659 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 660 if err != nil { 661 return out, metadata, &smithy.SerializationError{Err: err} 662 } 663 664 restEncoder.SetHeader("Content-Type").String("application/json") 665 666 jsonEncoder := smithyjson.NewEncoder() 667 if err := awsRestjson1_serializeOpDocumentListEventsInput(input, jsonEncoder.Value); err != nil { 668 return out, metadata, &smithy.SerializationError{Err: err} 669 } 670 671 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 672 return out, metadata, &smithy.SerializationError{Err: err} 673 } 674 675 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 676 return out, metadata, &smithy.SerializationError{Err: err} 677 } 678 in.Request = request 679 680 return next.HandleSerialize(ctx, in) 681} 682func awsRestjson1_serializeOpHttpBindingsListEventsInput(v *ListEventsInput, encoder *httpbinding.Encoder) error { 683 if v == nil { 684 return fmt.Errorf("unsupported serialization of nil %T", v) 685 } 686 687 return nil 688} 689 690func awsRestjson1_serializeOpDocumentListEventsInput(v *ListEventsInput, value smithyjson.Value) error { 691 object := value.Object() 692 defer object.Close() 693 694 if v.Filters != nil { 695 ok := object.Key("Filters") 696 if err := awsRestjson1_serializeDocumentListEventsFilters(v.Filters, ok); err != nil { 697 return err 698 } 699 } 700 701 if v.MaxResults != nil { 702 ok := object.Key("MaxResults") 703 ok.Integer(*v.MaxResults) 704 } 705 706 if v.NextToken != nil { 707 ok := object.Key("NextToken") 708 ok.String(*v.NextToken) 709 } 710 711 return nil 712} 713 714type awsRestjson1_serializeOpListInsights struct { 715} 716 717func (*awsRestjson1_serializeOpListInsights) ID() string { 718 return "OperationSerializer" 719} 720 721func (m *awsRestjson1_serializeOpListInsights) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 722 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 723) { 724 request, ok := in.Request.(*smithyhttp.Request) 725 if !ok { 726 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 727 } 728 729 input, ok := in.Parameters.(*ListInsightsInput) 730 _ = input 731 if !ok { 732 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 733 } 734 735 opPath, opQuery := httpbinding.SplitURI("/insights") 736 request.URL.Path = opPath 737 if len(request.URL.RawQuery) > 0 { 738 request.URL.RawQuery = "&" + opQuery 739 } else { 740 request.URL.RawQuery = opQuery 741 } 742 743 request.Method = "POST" 744 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 745 if err != nil { 746 return out, metadata, &smithy.SerializationError{Err: err} 747 } 748 749 restEncoder.SetHeader("Content-Type").String("application/json") 750 751 jsonEncoder := smithyjson.NewEncoder() 752 if err := awsRestjson1_serializeOpDocumentListInsightsInput(input, jsonEncoder.Value); err != nil { 753 return out, metadata, &smithy.SerializationError{Err: err} 754 } 755 756 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 757 return out, metadata, &smithy.SerializationError{Err: err} 758 } 759 760 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 761 return out, metadata, &smithy.SerializationError{Err: err} 762 } 763 in.Request = request 764 765 return next.HandleSerialize(ctx, in) 766} 767func awsRestjson1_serializeOpHttpBindingsListInsightsInput(v *ListInsightsInput, encoder *httpbinding.Encoder) error { 768 if v == nil { 769 return fmt.Errorf("unsupported serialization of nil %T", v) 770 } 771 772 return nil 773} 774 775func awsRestjson1_serializeOpDocumentListInsightsInput(v *ListInsightsInput, value smithyjson.Value) error { 776 object := value.Object() 777 defer object.Close() 778 779 if v.MaxResults != nil { 780 ok := object.Key("MaxResults") 781 ok.Integer(*v.MaxResults) 782 } 783 784 if v.NextToken != nil { 785 ok := object.Key("NextToken") 786 ok.String(*v.NextToken) 787 } 788 789 if v.StatusFilter != nil { 790 ok := object.Key("StatusFilter") 791 if err := awsRestjson1_serializeDocumentListInsightsStatusFilter(v.StatusFilter, ok); err != nil { 792 return err 793 } 794 } 795 796 return nil 797} 798 799type awsRestjson1_serializeOpListNotificationChannels struct { 800} 801 802func (*awsRestjson1_serializeOpListNotificationChannels) ID() string { 803 return "OperationSerializer" 804} 805 806func (m *awsRestjson1_serializeOpListNotificationChannels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 807 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 808) { 809 request, ok := in.Request.(*smithyhttp.Request) 810 if !ok { 811 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 812 } 813 814 input, ok := in.Parameters.(*ListNotificationChannelsInput) 815 _ = input 816 if !ok { 817 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 818 } 819 820 opPath, opQuery := httpbinding.SplitURI("/channels") 821 request.URL.Path = opPath 822 if len(request.URL.RawQuery) > 0 { 823 request.URL.RawQuery = "&" + opQuery 824 } else { 825 request.URL.RawQuery = opQuery 826 } 827 828 request.Method = "POST" 829 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 830 if err != nil { 831 return out, metadata, &smithy.SerializationError{Err: err} 832 } 833 834 restEncoder.SetHeader("Content-Type").String("application/json") 835 836 jsonEncoder := smithyjson.NewEncoder() 837 if err := awsRestjson1_serializeOpDocumentListNotificationChannelsInput(input, jsonEncoder.Value); err != nil { 838 return out, metadata, &smithy.SerializationError{Err: err} 839 } 840 841 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 842 return out, metadata, &smithy.SerializationError{Err: err} 843 } 844 845 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 846 return out, metadata, &smithy.SerializationError{Err: err} 847 } 848 in.Request = request 849 850 return next.HandleSerialize(ctx, in) 851} 852func awsRestjson1_serializeOpHttpBindingsListNotificationChannelsInput(v *ListNotificationChannelsInput, encoder *httpbinding.Encoder) error { 853 if v == nil { 854 return fmt.Errorf("unsupported serialization of nil %T", v) 855 } 856 857 return nil 858} 859 860func awsRestjson1_serializeOpDocumentListNotificationChannelsInput(v *ListNotificationChannelsInput, value smithyjson.Value) error { 861 object := value.Object() 862 defer object.Close() 863 864 if v.NextToken != nil { 865 ok := object.Key("NextToken") 866 ok.String(*v.NextToken) 867 } 868 869 return nil 870} 871 872type awsRestjson1_serializeOpListRecommendations struct { 873} 874 875func (*awsRestjson1_serializeOpListRecommendations) ID() string { 876 return "OperationSerializer" 877} 878 879func (m *awsRestjson1_serializeOpListRecommendations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 880 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 881) { 882 request, ok := in.Request.(*smithyhttp.Request) 883 if !ok { 884 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 885 } 886 887 input, ok := in.Parameters.(*ListRecommendationsInput) 888 _ = input 889 if !ok { 890 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 891 } 892 893 opPath, opQuery := httpbinding.SplitURI("/recommendations") 894 request.URL.Path = opPath 895 if len(request.URL.RawQuery) > 0 { 896 request.URL.RawQuery = "&" + opQuery 897 } else { 898 request.URL.RawQuery = opQuery 899 } 900 901 request.Method = "POST" 902 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 903 if err != nil { 904 return out, metadata, &smithy.SerializationError{Err: err} 905 } 906 907 restEncoder.SetHeader("Content-Type").String("application/json") 908 909 jsonEncoder := smithyjson.NewEncoder() 910 if err := awsRestjson1_serializeOpDocumentListRecommendationsInput(input, jsonEncoder.Value); err != nil { 911 return out, metadata, &smithy.SerializationError{Err: err} 912 } 913 914 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 915 return out, metadata, &smithy.SerializationError{Err: err} 916 } 917 918 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 919 return out, metadata, &smithy.SerializationError{Err: err} 920 } 921 in.Request = request 922 923 return next.HandleSerialize(ctx, in) 924} 925func awsRestjson1_serializeOpHttpBindingsListRecommendationsInput(v *ListRecommendationsInput, encoder *httpbinding.Encoder) error { 926 if v == nil { 927 return fmt.Errorf("unsupported serialization of nil %T", v) 928 } 929 930 return nil 931} 932 933func awsRestjson1_serializeOpDocumentListRecommendationsInput(v *ListRecommendationsInput, value smithyjson.Value) error { 934 object := value.Object() 935 defer object.Close() 936 937 if v.InsightId != nil { 938 ok := object.Key("InsightId") 939 ok.String(*v.InsightId) 940 } 941 942 if v.NextToken != nil { 943 ok := object.Key("NextToken") 944 ok.String(*v.NextToken) 945 } 946 947 return nil 948} 949 950type awsRestjson1_serializeOpPutFeedback struct { 951} 952 953func (*awsRestjson1_serializeOpPutFeedback) ID() string { 954 return "OperationSerializer" 955} 956 957func (m *awsRestjson1_serializeOpPutFeedback) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 958 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 959) { 960 request, ok := in.Request.(*smithyhttp.Request) 961 if !ok { 962 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 963 } 964 965 input, ok := in.Parameters.(*PutFeedbackInput) 966 _ = input 967 if !ok { 968 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 969 } 970 971 opPath, opQuery := httpbinding.SplitURI("/feedback") 972 request.URL.Path = opPath 973 if len(request.URL.RawQuery) > 0 { 974 request.URL.RawQuery = "&" + opQuery 975 } else { 976 request.URL.RawQuery = opQuery 977 } 978 979 request.Method = "PUT" 980 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 981 if err != nil { 982 return out, metadata, &smithy.SerializationError{Err: err} 983 } 984 985 restEncoder.SetHeader("Content-Type").String("application/json") 986 987 jsonEncoder := smithyjson.NewEncoder() 988 if err := awsRestjson1_serializeOpDocumentPutFeedbackInput(input, jsonEncoder.Value); err != nil { 989 return out, metadata, &smithy.SerializationError{Err: err} 990 } 991 992 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 993 return out, metadata, &smithy.SerializationError{Err: err} 994 } 995 996 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 997 return out, metadata, &smithy.SerializationError{Err: err} 998 } 999 in.Request = request 1000 1001 return next.HandleSerialize(ctx, in) 1002} 1003func awsRestjson1_serializeOpHttpBindingsPutFeedbackInput(v *PutFeedbackInput, encoder *httpbinding.Encoder) error { 1004 if v == nil { 1005 return fmt.Errorf("unsupported serialization of nil %T", v) 1006 } 1007 1008 return nil 1009} 1010 1011func awsRestjson1_serializeOpDocumentPutFeedbackInput(v *PutFeedbackInput, value smithyjson.Value) error { 1012 object := value.Object() 1013 defer object.Close() 1014 1015 if v.InsightFeedback != nil { 1016 ok := object.Key("InsightFeedback") 1017 if err := awsRestjson1_serializeDocumentInsightFeedback(v.InsightFeedback, ok); err != nil { 1018 return err 1019 } 1020 } 1021 1022 return nil 1023} 1024 1025type awsRestjson1_serializeOpRemoveNotificationChannel struct { 1026} 1027 1028func (*awsRestjson1_serializeOpRemoveNotificationChannel) ID() string { 1029 return "OperationSerializer" 1030} 1031 1032func (m *awsRestjson1_serializeOpRemoveNotificationChannel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1033 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1034) { 1035 request, ok := in.Request.(*smithyhttp.Request) 1036 if !ok { 1037 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1038 } 1039 1040 input, ok := in.Parameters.(*RemoveNotificationChannelInput) 1041 _ = input 1042 if !ok { 1043 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1044 } 1045 1046 opPath, opQuery := httpbinding.SplitURI("/channels/{Id}") 1047 request.URL.Path = opPath 1048 if len(request.URL.RawQuery) > 0 { 1049 request.URL.RawQuery = "&" + opQuery 1050 } else { 1051 request.URL.RawQuery = opQuery 1052 } 1053 1054 request.Method = "DELETE" 1055 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1056 if err != nil { 1057 return out, metadata, &smithy.SerializationError{Err: err} 1058 } 1059 1060 if err := awsRestjson1_serializeOpHttpBindingsRemoveNotificationChannelInput(input, restEncoder); err != nil { 1061 return out, metadata, &smithy.SerializationError{Err: err} 1062 } 1063 1064 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1065 return out, metadata, &smithy.SerializationError{Err: err} 1066 } 1067 in.Request = request 1068 1069 return next.HandleSerialize(ctx, in) 1070} 1071func awsRestjson1_serializeOpHttpBindingsRemoveNotificationChannelInput(v *RemoveNotificationChannelInput, encoder *httpbinding.Encoder) error { 1072 if v == nil { 1073 return fmt.Errorf("unsupported serialization of nil %T", v) 1074 } 1075 1076 if v.Id == nil || len(*v.Id) == 0 { 1077 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 1078 } 1079 if v.Id != nil { 1080 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 1081 return err 1082 } 1083 } 1084 1085 return nil 1086} 1087 1088type awsRestjson1_serializeOpSearchInsights struct { 1089} 1090 1091func (*awsRestjson1_serializeOpSearchInsights) ID() string { 1092 return "OperationSerializer" 1093} 1094 1095func (m *awsRestjson1_serializeOpSearchInsights) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1096 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1097) { 1098 request, ok := in.Request.(*smithyhttp.Request) 1099 if !ok { 1100 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1101 } 1102 1103 input, ok := in.Parameters.(*SearchInsightsInput) 1104 _ = input 1105 if !ok { 1106 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1107 } 1108 1109 opPath, opQuery := httpbinding.SplitURI("/insights/search") 1110 request.URL.Path = opPath 1111 if len(request.URL.RawQuery) > 0 { 1112 request.URL.RawQuery = "&" + opQuery 1113 } else { 1114 request.URL.RawQuery = opQuery 1115 } 1116 1117 request.Method = "POST" 1118 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1119 if err != nil { 1120 return out, metadata, &smithy.SerializationError{Err: err} 1121 } 1122 1123 restEncoder.SetHeader("Content-Type").String("application/json") 1124 1125 jsonEncoder := smithyjson.NewEncoder() 1126 if err := awsRestjson1_serializeOpDocumentSearchInsightsInput(input, jsonEncoder.Value); err != nil { 1127 return out, metadata, &smithy.SerializationError{Err: err} 1128 } 1129 1130 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1131 return out, metadata, &smithy.SerializationError{Err: err} 1132 } 1133 1134 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1135 return out, metadata, &smithy.SerializationError{Err: err} 1136 } 1137 in.Request = request 1138 1139 return next.HandleSerialize(ctx, in) 1140} 1141func awsRestjson1_serializeOpHttpBindingsSearchInsightsInput(v *SearchInsightsInput, encoder *httpbinding.Encoder) error { 1142 if v == nil { 1143 return fmt.Errorf("unsupported serialization of nil %T", v) 1144 } 1145 1146 return nil 1147} 1148 1149func awsRestjson1_serializeOpDocumentSearchInsightsInput(v *SearchInsightsInput, value smithyjson.Value) error { 1150 object := value.Object() 1151 defer object.Close() 1152 1153 if v.Filters != nil { 1154 ok := object.Key("Filters") 1155 if err := awsRestjson1_serializeDocumentSearchInsightsFilters(v.Filters, ok); err != nil { 1156 return err 1157 } 1158 } 1159 1160 if v.MaxResults != nil { 1161 ok := object.Key("MaxResults") 1162 ok.Integer(*v.MaxResults) 1163 } 1164 1165 if v.NextToken != nil { 1166 ok := object.Key("NextToken") 1167 ok.String(*v.NextToken) 1168 } 1169 1170 if v.StartTimeRange != nil { 1171 ok := object.Key("StartTimeRange") 1172 if err := awsRestjson1_serializeDocumentStartTimeRange(v.StartTimeRange, ok); err != nil { 1173 return err 1174 } 1175 } 1176 1177 if len(v.Type) > 0 { 1178 ok := object.Key("Type") 1179 ok.String(string(v.Type)) 1180 } 1181 1182 return nil 1183} 1184 1185type awsRestjson1_serializeOpUpdateResourceCollection struct { 1186} 1187 1188func (*awsRestjson1_serializeOpUpdateResourceCollection) ID() string { 1189 return "OperationSerializer" 1190} 1191 1192func (m *awsRestjson1_serializeOpUpdateResourceCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1193 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1194) { 1195 request, ok := in.Request.(*smithyhttp.Request) 1196 if !ok { 1197 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1198 } 1199 1200 input, ok := in.Parameters.(*UpdateResourceCollectionInput) 1201 _ = input 1202 if !ok { 1203 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1204 } 1205 1206 opPath, opQuery := httpbinding.SplitURI("/resource-collections") 1207 request.URL.Path = opPath 1208 if len(request.URL.RawQuery) > 0 { 1209 request.URL.RawQuery = "&" + opQuery 1210 } else { 1211 request.URL.RawQuery = opQuery 1212 } 1213 1214 request.Method = "PUT" 1215 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1216 if err != nil { 1217 return out, metadata, &smithy.SerializationError{Err: err} 1218 } 1219 1220 restEncoder.SetHeader("Content-Type").String("application/json") 1221 1222 jsonEncoder := smithyjson.NewEncoder() 1223 if err := awsRestjson1_serializeOpDocumentUpdateResourceCollectionInput(input, jsonEncoder.Value); err != nil { 1224 return out, metadata, &smithy.SerializationError{Err: err} 1225 } 1226 1227 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1228 return out, metadata, &smithy.SerializationError{Err: err} 1229 } 1230 1231 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1232 return out, metadata, &smithy.SerializationError{Err: err} 1233 } 1234 in.Request = request 1235 1236 return next.HandleSerialize(ctx, in) 1237} 1238func awsRestjson1_serializeOpHttpBindingsUpdateResourceCollectionInput(v *UpdateResourceCollectionInput, encoder *httpbinding.Encoder) error { 1239 if v == nil { 1240 return fmt.Errorf("unsupported serialization of nil %T", v) 1241 } 1242 1243 return nil 1244} 1245 1246func awsRestjson1_serializeOpDocumentUpdateResourceCollectionInput(v *UpdateResourceCollectionInput, value smithyjson.Value) error { 1247 object := value.Object() 1248 defer object.Close() 1249 1250 if len(v.Action) > 0 { 1251 ok := object.Key("Action") 1252 ok.String(string(v.Action)) 1253 } 1254 1255 if v.ResourceCollection != nil { 1256 ok := object.Key("ResourceCollection") 1257 if err := awsRestjson1_serializeDocumentUpdateResourceCollectionFilter(v.ResourceCollection, ok); err != nil { 1258 return err 1259 } 1260 } 1261 1262 return nil 1263} 1264 1265type awsRestjson1_serializeOpUpdateServiceIntegration struct { 1266} 1267 1268func (*awsRestjson1_serializeOpUpdateServiceIntegration) ID() string { 1269 return "OperationSerializer" 1270} 1271 1272func (m *awsRestjson1_serializeOpUpdateServiceIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1273 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1274) { 1275 request, ok := in.Request.(*smithyhttp.Request) 1276 if !ok { 1277 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1278 } 1279 1280 input, ok := in.Parameters.(*UpdateServiceIntegrationInput) 1281 _ = input 1282 if !ok { 1283 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1284 } 1285 1286 opPath, opQuery := httpbinding.SplitURI("/service-integrations") 1287 request.URL.Path = opPath 1288 if len(request.URL.RawQuery) > 0 { 1289 request.URL.RawQuery = "&" + opQuery 1290 } else { 1291 request.URL.RawQuery = opQuery 1292 } 1293 1294 request.Method = "PUT" 1295 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1296 if err != nil { 1297 return out, metadata, &smithy.SerializationError{Err: err} 1298 } 1299 1300 restEncoder.SetHeader("Content-Type").String("application/json") 1301 1302 jsonEncoder := smithyjson.NewEncoder() 1303 if err := awsRestjson1_serializeOpDocumentUpdateServiceIntegrationInput(input, jsonEncoder.Value); err != nil { 1304 return out, metadata, &smithy.SerializationError{Err: err} 1305 } 1306 1307 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1308 return out, metadata, &smithy.SerializationError{Err: err} 1309 } 1310 1311 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1312 return out, metadata, &smithy.SerializationError{Err: err} 1313 } 1314 in.Request = request 1315 1316 return next.HandleSerialize(ctx, in) 1317} 1318func awsRestjson1_serializeOpHttpBindingsUpdateServiceIntegrationInput(v *UpdateServiceIntegrationInput, encoder *httpbinding.Encoder) error { 1319 if v == nil { 1320 return fmt.Errorf("unsupported serialization of nil %T", v) 1321 } 1322 1323 return nil 1324} 1325 1326func awsRestjson1_serializeOpDocumentUpdateServiceIntegrationInput(v *UpdateServiceIntegrationInput, value smithyjson.Value) error { 1327 object := value.Object() 1328 defer object.Close() 1329 1330 if v.ServiceIntegration != nil { 1331 ok := object.Key("ServiceIntegration") 1332 if err := awsRestjson1_serializeDocumentUpdateServiceIntegrationConfig(v.ServiceIntegration, ok); err != nil { 1333 return err 1334 } 1335 } 1336 1337 return nil 1338} 1339 1340func awsRestjson1_serializeDocumentCloudFormationCollection(v *types.CloudFormationCollection, value smithyjson.Value) error { 1341 object := value.Object() 1342 defer object.Close() 1343 1344 if v.StackNames != nil { 1345 ok := object.Key("StackNames") 1346 if err := awsRestjson1_serializeDocumentStackNames(v.StackNames, ok); err != nil { 1347 return err 1348 } 1349 } 1350 1351 return nil 1352} 1353 1354func awsRestjson1_serializeDocumentEndTimeRange(v *types.EndTimeRange, value smithyjson.Value) error { 1355 object := value.Object() 1356 defer object.Close() 1357 1358 if v.FromTime != nil { 1359 ok := object.Key("FromTime") 1360 ok.Double(smithytime.FormatEpochSeconds(*v.FromTime)) 1361 } 1362 1363 if v.ToTime != nil { 1364 ok := object.Key("ToTime") 1365 ok.Double(smithytime.FormatEpochSeconds(*v.ToTime)) 1366 } 1367 1368 return nil 1369} 1370 1371func awsRestjson1_serializeDocumentEventTimeRange(v *types.EventTimeRange, value smithyjson.Value) error { 1372 object := value.Object() 1373 defer object.Close() 1374 1375 if v.FromTime != nil { 1376 ok := object.Key("FromTime") 1377 ok.Double(smithytime.FormatEpochSeconds(*v.FromTime)) 1378 } 1379 1380 if v.ToTime != nil { 1381 ok := object.Key("ToTime") 1382 ok.Double(smithytime.FormatEpochSeconds(*v.ToTime)) 1383 } 1384 1385 return nil 1386} 1387 1388func awsRestjson1_serializeDocumentInsightFeedback(v *types.InsightFeedback, value smithyjson.Value) error { 1389 object := value.Object() 1390 defer object.Close() 1391 1392 if len(v.Feedback) > 0 { 1393 ok := object.Key("Feedback") 1394 ok.String(string(v.Feedback)) 1395 } 1396 1397 if v.Id != nil { 1398 ok := object.Key("Id") 1399 ok.String(*v.Id) 1400 } 1401 1402 return nil 1403} 1404 1405func awsRestjson1_serializeDocumentInsightSeverities(v []types.InsightSeverity, value smithyjson.Value) error { 1406 array := value.Array() 1407 defer array.Close() 1408 1409 for i := range v { 1410 av := array.Value() 1411 av.String(string(v[i])) 1412 } 1413 return nil 1414} 1415 1416func awsRestjson1_serializeDocumentInsightStatuses(v []types.InsightStatus, value smithyjson.Value) error { 1417 array := value.Array() 1418 defer array.Close() 1419 1420 for i := range v { 1421 av := array.Value() 1422 av.String(string(v[i])) 1423 } 1424 return nil 1425} 1426 1427func awsRestjson1_serializeDocumentListEventsFilters(v *types.ListEventsFilters, value smithyjson.Value) error { 1428 object := value.Object() 1429 defer object.Close() 1430 1431 if len(v.DataSource) > 0 { 1432 ok := object.Key("DataSource") 1433 ok.String(string(v.DataSource)) 1434 } 1435 1436 if len(v.EventClass) > 0 { 1437 ok := object.Key("EventClass") 1438 ok.String(string(v.EventClass)) 1439 } 1440 1441 if v.EventSource != nil { 1442 ok := object.Key("EventSource") 1443 ok.String(*v.EventSource) 1444 } 1445 1446 if v.EventTimeRange != nil { 1447 ok := object.Key("EventTimeRange") 1448 if err := awsRestjson1_serializeDocumentEventTimeRange(v.EventTimeRange, ok); err != nil { 1449 return err 1450 } 1451 } 1452 1453 if v.InsightId != nil { 1454 ok := object.Key("InsightId") 1455 ok.String(*v.InsightId) 1456 } 1457 1458 if v.ResourceCollection != nil { 1459 ok := object.Key("ResourceCollection") 1460 if err := awsRestjson1_serializeDocumentResourceCollection(v.ResourceCollection, ok); err != nil { 1461 return err 1462 } 1463 } 1464 1465 return nil 1466} 1467 1468func awsRestjson1_serializeDocumentListInsightsAnyStatusFilter(v *types.ListInsightsAnyStatusFilter, value smithyjson.Value) error { 1469 object := value.Object() 1470 defer object.Close() 1471 1472 if v.StartTimeRange != nil { 1473 ok := object.Key("StartTimeRange") 1474 if err := awsRestjson1_serializeDocumentStartTimeRange(v.StartTimeRange, ok); err != nil { 1475 return err 1476 } 1477 } 1478 1479 if len(v.Type) > 0 { 1480 ok := object.Key("Type") 1481 ok.String(string(v.Type)) 1482 } 1483 1484 return nil 1485} 1486 1487func awsRestjson1_serializeDocumentListInsightsClosedStatusFilter(v *types.ListInsightsClosedStatusFilter, value smithyjson.Value) error { 1488 object := value.Object() 1489 defer object.Close() 1490 1491 if v.EndTimeRange != nil { 1492 ok := object.Key("EndTimeRange") 1493 if err := awsRestjson1_serializeDocumentEndTimeRange(v.EndTimeRange, ok); err != nil { 1494 return err 1495 } 1496 } 1497 1498 if len(v.Type) > 0 { 1499 ok := object.Key("Type") 1500 ok.String(string(v.Type)) 1501 } 1502 1503 return nil 1504} 1505 1506func awsRestjson1_serializeDocumentListInsightsOngoingStatusFilter(v *types.ListInsightsOngoingStatusFilter, value smithyjson.Value) error { 1507 object := value.Object() 1508 defer object.Close() 1509 1510 if len(v.Type) > 0 { 1511 ok := object.Key("Type") 1512 ok.String(string(v.Type)) 1513 } 1514 1515 return nil 1516} 1517 1518func awsRestjson1_serializeDocumentListInsightsStatusFilter(v *types.ListInsightsStatusFilter, value smithyjson.Value) error { 1519 object := value.Object() 1520 defer object.Close() 1521 1522 if v.Any != nil { 1523 ok := object.Key("Any") 1524 if err := awsRestjson1_serializeDocumentListInsightsAnyStatusFilter(v.Any, ok); err != nil { 1525 return err 1526 } 1527 } 1528 1529 if v.Closed != nil { 1530 ok := object.Key("Closed") 1531 if err := awsRestjson1_serializeDocumentListInsightsClosedStatusFilter(v.Closed, ok); err != nil { 1532 return err 1533 } 1534 } 1535 1536 if v.Ongoing != nil { 1537 ok := object.Key("Ongoing") 1538 if err := awsRestjson1_serializeDocumentListInsightsOngoingStatusFilter(v.Ongoing, ok); err != nil { 1539 return err 1540 } 1541 } 1542 1543 return nil 1544} 1545 1546func awsRestjson1_serializeDocumentNotificationChannelConfig(v *types.NotificationChannelConfig, value smithyjson.Value) error { 1547 object := value.Object() 1548 defer object.Close() 1549 1550 if v.Sns != nil { 1551 ok := object.Key("Sns") 1552 if err := awsRestjson1_serializeDocumentSnsChannelConfig(v.Sns, ok); err != nil { 1553 return err 1554 } 1555 } 1556 1557 return nil 1558} 1559 1560func awsRestjson1_serializeDocumentOpsCenterIntegrationConfig(v *types.OpsCenterIntegrationConfig, value smithyjson.Value) error { 1561 object := value.Object() 1562 defer object.Close() 1563 1564 if len(v.OptInStatus) > 0 { 1565 ok := object.Key("OptInStatus") 1566 ok.String(string(v.OptInStatus)) 1567 } 1568 1569 return nil 1570} 1571 1572func awsRestjson1_serializeDocumentResourceCollection(v *types.ResourceCollection, value smithyjson.Value) error { 1573 object := value.Object() 1574 defer object.Close() 1575 1576 if v.CloudFormation != nil { 1577 ok := object.Key("CloudFormation") 1578 if err := awsRestjson1_serializeDocumentCloudFormationCollection(v.CloudFormation, ok); err != nil { 1579 return err 1580 } 1581 } 1582 1583 return nil 1584} 1585 1586func awsRestjson1_serializeDocumentSearchInsightsFilters(v *types.SearchInsightsFilters, value smithyjson.Value) error { 1587 object := value.Object() 1588 defer object.Close() 1589 1590 if v.ResourceCollection != nil { 1591 ok := object.Key("ResourceCollection") 1592 if err := awsRestjson1_serializeDocumentResourceCollection(v.ResourceCollection, ok); err != nil { 1593 return err 1594 } 1595 } 1596 1597 if v.Severities != nil { 1598 ok := object.Key("Severities") 1599 if err := awsRestjson1_serializeDocumentInsightSeverities(v.Severities, ok); err != nil { 1600 return err 1601 } 1602 } 1603 1604 if v.Statuses != nil { 1605 ok := object.Key("Statuses") 1606 if err := awsRestjson1_serializeDocumentInsightStatuses(v.Statuses, ok); err != nil { 1607 return err 1608 } 1609 } 1610 1611 return nil 1612} 1613 1614func awsRestjson1_serializeDocumentSnsChannelConfig(v *types.SnsChannelConfig, value smithyjson.Value) error { 1615 object := value.Object() 1616 defer object.Close() 1617 1618 if v.TopicArn != nil { 1619 ok := object.Key("TopicArn") 1620 ok.String(*v.TopicArn) 1621 } 1622 1623 return nil 1624} 1625 1626func awsRestjson1_serializeDocumentStackNames(v []string, value smithyjson.Value) error { 1627 array := value.Array() 1628 defer array.Close() 1629 1630 for i := range v { 1631 av := array.Value() 1632 av.String(v[i]) 1633 } 1634 return nil 1635} 1636 1637func awsRestjson1_serializeDocumentStartTimeRange(v *types.StartTimeRange, value smithyjson.Value) error { 1638 object := value.Object() 1639 defer object.Close() 1640 1641 if v.FromTime != nil { 1642 ok := object.Key("FromTime") 1643 ok.Double(smithytime.FormatEpochSeconds(*v.FromTime)) 1644 } 1645 1646 if v.ToTime != nil { 1647 ok := object.Key("ToTime") 1648 ok.Double(smithytime.FormatEpochSeconds(*v.ToTime)) 1649 } 1650 1651 return nil 1652} 1653 1654func awsRestjson1_serializeDocumentUpdateCloudFormationCollectionFilter(v *types.UpdateCloudFormationCollectionFilter, value smithyjson.Value) error { 1655 object := value.Object() 1656 defer object.Close() 1657 1658 if v.StackNames != nil { 1659 ok := object.Key("StackNames") 1660 if err := awsRestjson1_serializeDocumentUpdateStackNames(v.StackNames, ok); err != nil { 1661 return err 1662 } 1663 } 1664 1665 return nil 1666} 1667 1668func awsRestjson1_serializeDocumentUpdateResourceCollectionFilter(v *types.UpdateResourceCollectionFilter, value smithyjson.Value) error { 1669 object := value.Object() 1670 defer object.Close() 1671 1672 if v.CloudFormation != nil { 1673 ok := object.Key("CloudFormation") 1674 if err := awsRestjson1_serializeDocumentUpdateCloudFormationCollectionFilter(v.CloudFormation, ok); err != nil { 1675 return err 1676 } 1677 } 1678 1679 return nil 1680} 1681 1682func awsRestjson1_serializeDocumentUpdateServiceIntegrationConfig(v *types.UpdateServiceIntegrationConfig, value smithyjson.Value) error { 1683 object := value.Object() 1684 defer object.Close() 1685 1686 if v.OpsCenter != nil { 1687 ok := object.Key("OpsCenter") 1688 if err := awsRestjson1_serializeDocumentOpsCenterIntegrationConfig(v.OpsCenter, ok); err != nil { 1689 return err 1690 } 1691 } 1692 1693 return nil 1694} 1695 1696func awsRestjson1_serializeDocumentUpdateStackNames(v []string, value smithyjson.Value) error { 1697 array := value.Array() 1698 defer array.Close() 1699 1700 for i := range v { 1701 av := array.Value() 1702 av.String(v[i]) 1703 } 1704 return nil 1705} 1706