1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package xray 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/xray/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_serializeOpBatchGetTraces struct { 19} 20 21func (*awsRestjson1_serializeOpBatchGetTraces) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpBatchGetTraces) 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.(*BatchGetTracesInput) 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("/Traces") 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_serializeOpDocumentBatchGetTracesInput(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_serializeOpHttpBindingsBatchGetTracesInput(v *BatchGetTracesInput, 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_serializeOpDocumentBatchGetTracesInput(v *BatchGetTracesInput, value smithyjson.Value) error { 75 object := value.Object() 76 defer object.Close() 77 78 if v.NextToken != nil { 79 ok := object.Key("NextToken") 80 ok.String(*v.NextToken) 81 } 82 83 if v.TraceIds != nil { 84 ok := object.Key("TraceIds") 85 if err := awsRestjson1_serializeDocumentTraceIdList(v.TraceIds, ok); err != nil { 86 return err 87 } 88 } 89 90 return nil 91} 92 93type awsRestjson1_serializeOpCreateGroup struct { 94} 95 96func (*awsRestjson1_serializeOpCreateGroup) ID() string { 97 return "OperationSerializer" 98} 99 100func (m *awsRestjson1_serializeOpCreateGroup) 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.(*CreateGroupInput) 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("/CreateGroup") 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_serializeOpDocumentCreateGroupInput(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_serializeOpHttpBindingsCreateGroupInput(v *CreateGroupInput, 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_serializeOpDocumentCreateGroupInput(v *CreateGroupInput, value smithyjson.Value) error { 150 object := value.Object() 151 defer object.Close() 152 153 if v.FilterExpression != nil { 154 ok := object.Key("FilterExpression") 155 ok.String(*v.FilterExpression) 156 } 157 158 if v.GroupName != nil { 159 ok := object.Key("GroupName") 160 ok.String(*v.GroupName) 161 } 162 163 if v.InsightsConfiguration != nil { 164 ok := object.Key("InsightsConfiguration") 165 if err := awsRestjson1_serializeDocumentInsightsConfiguration(v.InsightsConfiguration, ok); err != nil { 166 return err 167 } 168 } 169 170 if v.Tags != nil { 171 ok := object.Key("Tags") 172 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 173 return err 174 } 175 } 176 177 return nil 178} 179 180type awsRestjson1_serializeOpCreateSamplingRule struct { 181} 182 183func (*awsRestjson1_serializeOpCreateSamplingRule) ID() string { 184 return "OperationSerializer" 185} 186 187func (m *awsRestjson1_serializeOpCreateSamplingRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 188 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 189) { 190 request, ok := in.Request.(*smithyhttp.Request) 191 if !ok { 192 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 193 } 194 195 input, ok := in.Parameters.(*CreateSamplingRuleInput) 196 _ = input 197 if !ok { 198 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 199 } 200 201 opPath, opQuery := httpbinding.SplitURI("/CreateSamplingRule") 202 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 203 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 204 request.Method = "POST" 205 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 206 if err != nil { 207 return out, metadata, &smithy.SerializationError{Err: err} 208 } 209 210 restEncoder.SetHeader("Content-Type").String("application/json") 211 212 jsonEncoder := smithyjson.NewEncoder() 213 if err := awsRestjson1_serializeOpDocumentCreateSamplingRuleInput(input, jsonEncoder.Value); err != nil { 214 return out, metadata, &smithy.SerializationError{Err: err} 215 } 216 217 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 218 return out, metadata, &smithy.SerializationError{Err: err} 219 } 220 221 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 222 return out, metadata, &smithy.SerializationError{Err: err} 223 } 224 in.Request = request 225 226 return next.HandleSerialize(ctx, in) 227} 228func awsRestjson1_serializeOpHttpBindingsCreateSamplingRuleInput(v *CreateSamplingRuleInput, encoder *httpbinding.Encoder) error { 229 if v == nil { 230 return fmt.Errorf("unsupported serialization of nil %T", v) 231 } 232 233 return nil 234} 235 236func awsRestjson1_serializeOpDocumentCreateSamplingRuleInput(v *CreateSamplingRuleInput, value smithyjson.Value) error { 237 object := value.Object() 238 defer object.Close() 239 240 if v.SamplingRule != nil { 241 ok := object.Key("SamplingRule") 242 if err := awsRestjson1_serializeDocumentSamplingRule(v.SamplingRule, ok); err != nil { 243 return err 244 } 245 } 246 247 if v.Tags != nil { 248 ok := object.Key("Tags") 249 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 250 return err 251 } 252 } 253 254 return nil 255} 256 257type awsRestjson1_serializeOpDeleteGroup struct { 258} 259 260func (*awsRestjson1_serializeOpDeleteGroup) ID() string { 261 return "OperationSerializer" 262} 263 264func (m *awsRestjson1_serializeOpDeleteGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 265 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 266) { 267 request, ok := in.Request.(*smithyhttp.Request) 268 if !ok { 269 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 270 } 271 272 input, ok := in.Parameters.(*DeleteGroupInput) 273 _ = input 274 if !ok { 275 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 276 } 277 278 opPath, opQuery := httpbinding.SplitURI("/DeleteGroup") 279 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 280 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 281 request.Method = "POST" 282 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 283 if err != nil { 284 return out, metadata, &smithy.SerializationError{Err: err} 285 } 286 287 restEncoder.SetHeader("Content-Type").String("application/json") 288 289 jsonEncoder := smithyjson.NewEncoder() 290 if err := awsRestjson1_serializeOpDocumentDeleteGroupInput(input, jsonEncoder.Value); err != nil { 291 return out, metadata, &smithy.SerializationError{Err: err} 292 } 293 294 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 295 return out, metadata, &smithy.SerializationError{Err: err} 296 } 297 298 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 299 return out, metadata, &smithy.SerializationError{Err: err} 300 } 301 in.Request = request 302 303 return next.HandleSerialize(ctx, in) 304} 305func awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(v *DeleteGroupInput, encoder *httpbinding.Encoder) error { 306 if v == nil { 307 return fmt.Errorf("unsupported serialization of nil %T", v) 308 } 309 310 return nil 311} 312 313func awsRestjson1_serializeOpDocumentDeleteGroupInput(v *DeleteGroupInput, value smithyjson.Value) error { 314 object := value.Object() 315 defer object.Close() 316 317 if v.GroupARN != nil { 318 ok := object.Key("GroupARN") 319 ok.String(*v.GroupARN) 320 } 321 322 if v.GroupName != nil { 323 ok := object.Key("GroupName") 324 ok.String(*v.GroupName) 325 } 326 327 return nil 328} 329 330type awsRestjson1_serializeOpDeleteSamplingRule struct { 331} 332 333func (*awsRestjson1_serializeOpDeleteSamplingRule) ID() string { 334 return "OperationSerializer" 335} 336 337func (m *awsRestjson1_serializeOpDeleteSamplingRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 338 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 339) { 340 request, ok := in.Request.(*smithyhttp.Request) 341 if !ok { 342 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 343 } 344 345 input, ok := in.Parameters.(*DeleteSamplingRuleInput) 346 _ = input 347 if !ok { 348 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 349 } 350 351 opPath, opQuery := httpbinding.SplitURI("/DeleteSamplingRule") 352 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 353 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 354 request.Method = "POST" 355 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 356 if err != nil { 357 return out, metadata, &smithy.SerializationError{Err: err} 358 } 359 360 restEncoder.SetHeader("Content-Type").String("application/json") 361 362 jsonEncoder := smithyjson.NewEncoder() 363 if err := awsRestjson1_serializeOpDocumentDeleteSamplingRuleInput(input, jsonEncoder.Value); err != nil { 364 return out, metadata, &smithy.SerializationError{Err: err} 365 } 366 367 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 368 return out, metadata, &smithy.SerializationError{Err: err} 369 } 370 371 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 372 return out, metadata, &smithy.SerializationError{Err: err} 373 } 374 in.Request = request 375 376 return next.HandleSerialize(ctx, in) 377} 378func awsRestjson1_serializeOpHttpBindingsDeleteSamplingRuleInput(v *DeleteSamplingRuleInput, encoder *httpbinding.Encoder) error { 379 if v == nil { 380 return fmt.Errorf("unsupported serialization of nil %T", v) 381 } 382 383 return nil 384} 385 386func awsRestjson1_serializeOpDocumentDeleteSamplingRuleInput(v *DeleteSamplingRuleInput, value smithyjson.Value) error { 387 object := value.Object() 388 defer object.Close() 389 390 if v.RuleARN != nil { 391 ok := object.Key("RuleARN") 392 ok.String(*v.RuleARN) 393 } 394 395 if v.RuleName != nil { 396 ok := object.Key("RuleName") 397 ok.String(*v.RuleName) 398 } 399 400 return nil 401} 402 403type awsRestjson1_serializeOpGetEncryptionConfig struct { 404} 405 406func (*awsRestjson1_serializeOpGetEncryptionConfig) ID() string { 407 return "OperationSerializer" 408} 409 410func (m *awsRestjson1_serializeOpGetEncryptionConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 411 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 412) { 413 request, ok := in.Request.(*smithyhttp.Request) 414 if !ok { 415 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 416 } 417 418 input, ok := in.Parameters.(*GetEncryptionConfigInput) 419 _ = input 420 if !ok { 421 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 422 } 423 424 opPath, opQuery := httpbinding.SplitURI("/EncryptionConfig") 425 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 426 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 427 request.Method = "POST" 428 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 429 if err != nil { 430 return out, metadata, &smithy.SerializationError{Err: err} 431 } 432 433 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 434 return out, metadata, &smithy.SerializationError{Err: err} 435 } 436 in.Request = request 437 438 return next.HandleSerialize(ctx, in) 439} 440func awsRestjson1_serializeOpHttpBindingsGetEncryptionConfigInput(v *GetEncryptionConfigInput, encoder *httpbinding.Encoder) error { 441 if v == nil { 442 return fmt.Errorf("unsupported serialization of nil %T", v) 443 } 444 445 return nil 446} 447 448type awsRestjson1_serializeOpGetGroup struct { 449} 450 451func (*awsRestjson1_serializeOpGetGroup) ID() string { 452 return "OperationSerializer" 453} 454 455func (m *awsRestjson1_serializeOpGetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 456 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 457) { 458 request, ok := in.Request.(*smithyhttp.Request) 459 if !ok { 460 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 461 } 462 463 input, ok := in.Parameters.(*GetGroupInput) 464 _ = input 465 if !ok { 466 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 467 } 468 469 opPath, opQuery := httpbinding.SplitURI("/GetGroup") 470 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 471 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 472 request.Method = "POST" 473 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 474 if err != nil { 475 return out, metadata, &smithy.SerializationError{Err: err} 476 } 477 478 restEncoder.SetHeader("Content-Type").String("application/json") 479 480 jsonEncoder := smithyjson.NewEncoder() 481 if err := awsRestjson1_serializeOpDocumentGetGroupInput(input, jsonEncoder.Value); err != nil { 482 return out, metadata, &smithy.SerializationError{Err: err} 483 } 484 485 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 486 return out, metadata, &smithy.SerializationError{Err: err} 487 } 488 489 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 490 return out, metadata, &smithy.SerializationError{Err: err} 491 } 492 in.Request = request 493 494 return next.HandleSerialize(ctx, in) 495} 496func awsRestjson1_serializeOpHttpBindingsGetGroupInput(v *GetGroupInput, encoder *httpbinding.Encoder) error { 497 if v == nil { 498 return fmt.Errorf("unsupported serialization of nil %T", v) 499 } 500 501 return nil 502} 503 504func awsRestjson1_serializeOpDocumentGetGroupInput(v *GetGroupInput, value smithyjson.Value) error { 505 object := value.Object() 506 defer object.Close() 507 508 if v.GroupARN != nil { 509 ok := object.Key("GroupARN") 510 ok.String(*v.GroupARN) 511 } 512 513 if v.GroupName != nil { 514 ok := object.Key("GroupName") 515 ok.String(*v.GroupName) 516 } 517 518 return nil 519} 520 521type awsRestjson1_serializeOpGetGroups struct { 522} 523 524func (*awsRestjson1_serializeOpGetGroups) ID() string { 525 return "OperationSerializer" 526} 527 528func (m *awsRestjson1_serializeOpGetGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 529 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 530) { 531 request, ok := in.Request.(*smithyhttp.Request) 532 if !ok { 533 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 534 } 535 536 input, ok := in.Parameters.(*GetGroupsInput) 537 _ = input 538 if !ok { 539 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 540 } 541 542 opPath, opQuery := httpbinding.SplitURI("/Groups") 543 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 544 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 545 request.Method = "POST" 546 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 547 if err != nil { 548 return out, metadata, &smithy.SerializationError{Err: err} 549 } 550 551 restEncoder.SetHeader("Content-Type").String("application/json") 552 553 jsonEncoder := smithyjson.NewEncoder() 554 if err := awsRestjson1_serializeOpDocumentGetGroupsInput(input, jsonEncoder.Value); err != nil { 555 return out, metadata, &smithy.SerializationError{Err: err} 556 } 557 558 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 559 return out, metadata, &smithy.SerializationError{Err: err} 560 } 561 562 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 563 return out, metadata, &smithy.SerializationError{Err: err} 564 } 565 in.Request = request 566 567 return next.HandleSerialize(ctx, in) 568} 569func awsRestjson1_serializeOpHttpBindingsGetGroupsInput(v *GetGroupsInput, encoder *httpbinding.Encoder) error { 570 if v == nil { 571 return fmt.Errorf("unsupported serialization of nil %T", v) 572 } 573 574 return nil 575} 576 577func awsRestjson1_serializeOpDocumentGetGroupsInput(v *GetGroupsInput, value smithyjson.Value) error { 578 object := value.Object() 579 defer object.Close() 580 581 if v.NextToken != nil { 582 ok := object.Key("NextToken") 583 ok.String(*v.NextToken) 584 } 585 586 return nil 587} 588 589type awsRestjson1_serializeOpGetInsight struct { 590} 591 592func (*awsRestjson1_serializeOpGetInsight) ID() string { 593 return "OperationSerializer" 594} 595 596func (m *awsRestjson1_serializeOpGetInsight) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 597 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 598) { 599 request, ok := in.Request.(*smithyhttp.Request) 600 if !ok { 601 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 602 } 603 604 input, ok := in.Parameters.(*GetInsightInput) 605 _ = input 606 if !ok { 607 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 608 } 609 610 opPath, opQuery := httpbinding.SplitURI("/Insight") 611 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 612 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 613 request.Method = "POST" 614 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 615 if err != nil { 616 return out, metadata, &smithy.SerializationError{Err: err} 617 } 618 619 restEncoder.SetHeader("Content-Type").String("application/json") 620 621 jsonEncoder := smithyjson.NewEncoder() 622 if err := awsRestjson1_serializeOpDocumentGetInsightInput(input, jsonEncoder.Value); err != nil { 623 return out, metadata, &smithy.SerializationError{Err: err} 624 } 625 626 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 627 return out, metadata, &smithy.SerializationError{Err: err} 628 } 629 630 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 631 return out, metadata, &smithy.SerializationError{Err: err} 632 } 633 in.Request = request 634 635 return next.HandleSerialize(ctx, in) 636} 637func awsRestjson1_serializeOpHttpBindingsGetInsightInput(v *GetInsightInput, encoder *httpbinding.Encoder) error { 638 if v == nil { 639 return fmt.Errorf("unsupported serialization of nil %T", v) 640 } 641 642 return nil 643} 644 645func awsRestjson1_serializeOpDocumentGetInsightInput(v *GetInsightInput, value smithyjson.Value) error { 646 object := value.Object() 647 defer object.Close() 648 649 if v.InsightId != nil { 650 ok := object.Key("InsightId") 651 ok.String(*v.InsightId) 652 } 653 654 return nil 655} 656 657type awsRestjson1_serializeOpGetInsightEvents struct { 658} 659 660func (*awsRestjson1_serializeOpGetInsightEvents) ID() string { 661 return "OperationSerializer" 662} 663 664func (m *awsRestjson1_serializeOpGetInsightEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 665 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 666) { 667 request, ok := in.Request.(*smithyhttp.Request) 668 if !ok { 669 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 670 } 671 672 input, ok := in.Parameters.(*GetInsightEventsInput) 673 _ = input 674 if !ok { 675 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 676 } 677 678 opPath, opQuery := httpbinding.SplitURI("/InsightEvents") 679 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 680 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 681 request.Method = "POST" 682 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 683 if err != nil { 684 return out, metadata, &smithy.SerializationError{Err: err} 685 } 686 687 restEncoder.SetHeader("Content-Type").String("application/json") 688 689 jsonEncoder := smithyjson.NewEncoder() 690 if err := awsRestjson1_serializeOpDocumentGetInsightEventsInput(input, jsonEncoder.Value); err != nil { 691 return out, metadata, &smithy.SerializationError{Err: err} 692 } 693 694 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 695 return out, metadata, &smithy.SerializationError{Err: err} 696 } 697 698 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 699 return out, metadata, &smithy.SerializationError{Err: err} 700 } 701 in.Request = request 702 703 return next.HandleSerialize(ctx, in) 704} 705func awsRestjson1_serializeOpHttpBindingsGetInsightEventsInput(v *GetInsightEventsInput, encoder *httpbinding.Encoder) error { 706 if v == nil { 707 return fmt.Errorf("unsupported serialization of nil %T", v) 708 } 709 710 return nil 711} 712 713func awsRestjson1_serializeOpDocumentGetInsightEventsInput(v *GetInsightEventsInput, value smithyjson.Value) error { 714 object := value.Object() 715 defer object.Close() 716 717 if v.InsightId != nil { 718 ok := object.Key("InsightId") 719 ok.String(*v.InsightId) 720 } 721 722 if v.MaxResults != nil { 723 ok := object.Key("MaxResults") 724 ok.Integer(*v.MaxResults) 725 } 726 727 if v.NextToken != nil { 728 ok := object.Key("NextToken") 729 ok.String(*v.NextToken) 730 } 731 732 return nil 733} 734 735type awsRestjson1_serializeOpGetInsightImpactGraph struct { 736} 737 738func (*awsRestjson1_serializeOpGetInsightImpactGraph) ID() string { 739 return "OperationSerializer" 740} 741 742func (m *awsRestjson1_serializeOpGetInsightImpactGraph) 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.(*GetInsightImpactGraphInput) 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("/InsightImpactGraph") 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 restEncoder.SetHeader("Content-Type").String("application/json") 766 767 jsonEncoder := smithyjson.NewEncoder() 768 if err := awsRestjson1_serializeOpDocumentGetInsightImpactGraphInput(input, jsonEncoder.Value); err != nil { 769 return out, metadata, &smithy.SerializationError{Err: err} 770 } 771 772 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 773 return out, metadata, &smithy.SerializationError{Err: err} 774 } 775 776 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 777 return out, metadata, &smithy.SerializationError{Err: err} 778 } 779 in.Request = request 780 781 return next.HandleSerialize(ctx, in) 782} 783func awsRestjson1_serializeOpHttpBindingsGetInsightImpactGraphInput(v *GetInsightImpactGraphInput, encoder *httpbinding.Encoder) error { 784 if v == nil { 785 return fmt.Errorf("unsupported serialization of nil %T", v) 786 } 787 788 return nil 789} 790 791func awsRestjson1_serializeOpDocumentGetInsightImpactGraphInput(v *GetInsightImpactGraphInput, value smithyjson.Value) error { 792 object := value.Object() 793 defer object.Close() 794 795 if v.EndTime != nil { 796 ok := object.Key("EndTime") 797 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime)) 798 } 799 800 if v.InsightId != nil { 801 ok := object.Key("InsightId") 802 ok.String(*v.InsightId) 803 } 804 805 if v.NextToken != nil { 806 ok := object.Key("NextToken") 807 ok.String(*v.NextToken) 808 } 809 810 if v.StartTime != nil { 811 ok := object.Key("StartTime") 812 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime)) 813 } 814 815 return nil 816} 817 818type awsRestjson1_serializeOpGetInsightSummaries struct { 819} 820 821func (*awsRestjson1_serializeOpGetInsightSummaries) ID() string { 822 return "OperationSerializer" 823} 824 825func (m *awsRestjson1_serializeOpGetInsightSummaries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 826 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 827) { 828 request, ok := in.Request.(*smithyhttp.Request) 829 if !ok { 830 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 831 } 832 833 input, ok := in.Parameters.(*GetInsightSummariesInput) 834 _ = input 835 if !ok { 836 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 837 } 838 839 opPath, opQuery := httpbinding.SplitURI("/InsightSummaries") 840 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 841 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 842 request.Method = "POST" 843 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 844 if err != nil { 845 return out, metadata, &smithy.SerializationError{Err: err} 846 } 847 848 restEncoder.SetHeader("Content-Type").String("application/json") 849 850 jsonEncoder := smithyjson.NewEncoder() 851 if err := awsRestjson1_serializeOpDocumentGetInsightSummariesInput(input, jsonEncoder.Value); err != nil { 852 return out, metadata, &smithy.SerializationError{Err: err} 853 } 854 855 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 856 return out, metadata, &smithy.SerializationError{Err: err} 857 } 858 859 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 860 return out, metadata, &smithy.SerializationError{Err: err} 861 } 862 in.Request = request 863 864 return next.HandleSerialize(ctx, in) 865} 866func awsRestjson1_serializeOpHttpBindingsGetInsightSummariesInput(v *GetInsightSummariesInput, encoder *httpbinding.Encoder) error { 867 if v == nil { 868 return fmt.Errorf("unsupported serialization of nil %T", v) 869 } 870 871 return nil 872} 873 874func awsRestjson1_serializeOpDocumentGetInsightSummariesInput(v *GetInsightSummariesInput, value smithyjson.Value) error { 875 object := value.Object() 876 defer object.Close() 877 878 if v.EndTime != nil { 879 ok := object.Key("EndTime") 880 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime)) 881 } 882 883 if v.GroupARN != nil { 884 ok := object.Key("GroupARN") 885 ok.String(*v.GroupARN) 886 } 887 888 if v.GroupName != nil { 889 ok := object.Key("GroupName") 890 ok.String(*v.GroupName) 891 } 892 893 if v.MaxResults != nil { 894 ok := object.Key("MaxResults") 895 ok.Integer(*v.MaxResults) 896 } 897 898 if v.NextToken != nil { 899 ok := object.Key("NextToken") 900 ok.String(*v.NextToken) 901 } 902 903 if v.StartTime != nil { 904 ok := object.Key("StartTime") 905 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime)) 906 } 907 908 if v.States != nil { 909 ok := object.Key("States") 910 if err := awsRestjson1_serializeDocumentInsightStateList(v.States, ok); err != nil { 911 return err 912 } 913 } 914 915 return nil 916} 917 918type awsRestjson1_serializeOpGetSamplingRules struct { 919} 920 921func (*awsRestjson1_serializeOpGetSamplingRules) ID() string { 922 return "OperationSerializer" 923} 924 925func (m *awsRestjson1_serializeOpGetSamplingRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 926 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 927) { 928 request, ok := in.Request.(*smithyhttp.Request) 929 if !ok { 930 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 931 } 932 933 input, ok := in.Parameters.(*GetSamplingRulesInput) 934 _ = input 935 if !ok { 936 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 937 } 938 939 opPath, opQuery := httpbinding.SplitURI("/GetSamplingRules") 940 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 941 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 942 request.Method = "POST" 943 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 944 if err != nil { 945 return out, metadata, &smithy.SerializationError{Err: err} 946 } 947 948 restEncoder.SetHeader("Content-Type").String("application/json") 949 950 jsonEncoder := smithyjson.NewEncoder() 951 if err := awsRestjson1_serializeOpDocumentGetSamplingRulesInput(input, jsonEncoder.Value); err != nil { 952 return out, metadata, &smithy.SerializationError{Err: err} 953 } 954 955 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 956 return out, metadata, &smithy.SerializationError{Err: err} 957 } 958 959 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 960 return out, metadata, &smithy.SerializationError{Err: err} 961 } 962 in.Request = request 963 964 return next.HandleSerialize(ctx, in) 965} 966func awsRestjson1_serializeOpHttpBindingsGetSamplingRulesInput(v *GetSamplingRulesInput, encoder *httpbinding.Encoder) error { 967 if v == nil { 968 return fmt.Errorf("unsupported serialization of nil %T", v) 969 } 970 971 return nil 972} 973 974func awsRestjson1_serializeOpDocumentGetSamplingRulesInput(v *GetSamplingRulesInput, value smithyjson.Value) error { 975 object := value.Object() 976 defer object.Close() 977 978 if v.NextToken != nil { 979 ok := object.Key("NextToken") 980 ok.String(*v.NextToken) 981 } 982 983 return nil 984} 985 986type awsRestjson1_serializeOpGetSamplingStatisticSummaries struct { 987} 988 989func (*awsRestjson1_serializeOpGetSamplingStatisticSummaries) ID() string { 990 return "OperationSerializer" 991} 992 993func (m *awsRestjson1_serializeOpGetSamplingStatisticSummaries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 994 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 995) { 996 request, ok := in.Request.(*smithyhttp.Request) 997 if !ok { 998 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 999 } 1000 1001 input, ok := in.Parameters.(*GetSamplingStatisticSummariesInput) 1002 _ = input 1003 if !ok { 1004 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1005 } 1006 1007 opPath, opQuery := httpbinding.SplitURI("/SamplingStatisticSummaries") 1008 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1009 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1010 request.Method = "POST" 1011 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1012 if err != nil { 1013 return out, metadata, &smithy.SerializationError{Err: err} 1014 } 1015 1016 restEncoder.SetHeader("Content-Type").String("application/json") 1017 1018 jsonEncoder := smithyjson.NewEncoder() 1019 if err := awsRestjson1_serializeOpDocumentGetSamplingStatisticSummariesInput(input, jsonEncoder.Value); err != nil { 1020 return out, metadata, &smithy.SerializationError{Err: err} 1021 } 1022 1023 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1024 return out, metadata, &smithy.SerializationError{Err: err} 1025 } 1026 1027 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1028 return out, metadata, &smithy.SerializationError{Err: err} 1029 } 1030 in.Request = request 1031 1032 return next.HandleSerialize(ctx, in) 1033} 1034func awsRestjson1_serializeOpHttpBindingsGetSamplingStatisticSummariesInput(v *GetSamplingStatisticSummariesInput, encoder *httpbinding.Encoder) error { 1035 if v == nil { 1036 return fmt.Errorf("unsupported serialization of nil %T", v) 1037 } 1038 1039 return nil 1040} 1041 1042func awsRestjson1_serializeOpDocumentGetSamplingStatisticSummariesInput(v *GetSamplingStatisticSummariesInput, value smithyjson.Value) error { 1043 object := value.Object() 1044 defer object.Close() 1045 1046 if v.NextToken != nil { 1047 ok := object.Key("NextToken") 1048 ok.String(*v.NextToken) 1049 } 1050 1051 return nil 1052} 1053 1054type awsRestjson1_serializeOpGetSamplingTargets struct { 1055} 1056 1057func (*awsRestjson1_serializeOpGetSamplingTargets) ID() string { 1058 return "OperationSerializer" 1059} 1060 1061func (m *awsRestjson1_serializeOpGetSamplingTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1062 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1063) { 1064 request, ok := in.Request.(*smithyhttp.Request) 1065 if !ok { 1066 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1067 } 1068 1069 input, ok := in.Parameters.(*GetSamplingTargetsInput) 1070 _ = input 1071 if !ok { 1072 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1073 } 1074 1075 opPath, opQuery := httpbinding.SplitURI("/SamplingTargets") 1076 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1077 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1078 request.Method = "POST" 1079 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1080 if err != nil { 1081 return out, metadata, &smithy.SerializationError{Err: err} 1082 } 1083 1084 restEncoder.SetHeader("Content-Type").String("application/json") 1085 1086 jsonEncoder := smithyjson.NewEncoder() 1087 if err := awsRestjson1_serializeOpDocumentGetSamplingTargetsInput(input, jsonEncoder.Value); err != nil { 1088 return out, metadata, &smithy.SerializationError{Err: err} 1089 } 1090 1091 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1092 return out, metadata, &smithy.SerializationError{Err: err} 1093 } 1094 1095 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1096 return out, metadata, &smithy.SerializationError{Err: err} 1097 } 1098 in.Request = request 1099 1100 return next.HandleSerialize(ctx, in) 1101} 1102func awsRestjson1_serializeOpHttpBindingsGetSamplingTargetsInput(v *GetSamplingTargetsInput, encoder *httpbinding.Encoder) error { 1103 if v == nil { 1104 return fmt.Errorf("unsupported serialization of nil %T", v) 1105 } 1106 1107 return nil 1108} 1109 1110func awsRestjson1_serializeOpDocumentGetSamplingTargetsInput(v *GetSamplingTargetsInput, value smithyjson.Value) error { 1111 object := value.Object() 1112 defer object.Close() 1113 1114 if v.SamplingStatisticsDocuments != nil { 1115 ok := object.Key("SamplingStatisticsDocuments") 1116 if err := awsRestjson1_serializeDocumentSamplingStatisticsDocumentList(v.SamplingStatisticsDocuments, ok); err != nil { 1117 return err 1118 } 1119 } 1120 1121 return nil 1122} 1123 1124type awsRestjson1_serializeOpGetServiceGraph struct { 1125} 1126 1127func (*awsRestjson1_serializeOpGetServiceGraph) ID() string { 1128 return "OperationSerializer" 1129} 1130 1131func (m *awsRestjson1_serializeOpGetServiceGraph) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1132 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1133) { 1134 request, ok := in.Request.(*smithyhttp.Request) 1135 if !ok { 1136 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1137 } 1138 1139 input, ok := in.Parameters.(*GetServiceGraphInput) 1140 _ = input 1141 if !ok { 1142 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1143 } 1144 1145 opPath, opQuery := httpbinding.SplitURI("/ServiceGraph") 1146 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1147 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1148 request.Method = "POST" 1149 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1150 if err != nil { 1151 return out, metadata, &smithy.SerializationError{Err: err} 1152 } 1153 1154 restEncoder.SetHeader("Content-Type").String("application/json") 1155 1156 jsonEncoder := smithyjson.NewEncoder() 1157 if err := awsRestjson1_serializeOpDocumentGetServiceGraphInput(input, jsonEncoder.Value); err != nil { 1158 return out, metadata, &smithy.SerializationError{Err: err} 1159 } 1160 1161 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1162 return out, metadata, &smithy.SerializationError{Err: err} 1163 } 1164 1165 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1166 return out, metadata, &smithy.SerializationError{Err: err} 1167 } 1168 in.Request = request 1169 1170 return next.HandleSerialize(ctx, in) 1171} 1172func awsRestjson1_serializeOpHttpBindingsGetServiceGraphInput(v *GetServiceGraphInput, encoder *httpbinding.Encoder) error { 1173 if v == nil { 1174 return fmt.Errorf("unsupported serialization of nil %T", v) 1175 } 1176 1177 return nil 1178} 1179 1180func awsRestjson1_serializeOpDocumentGetServiceGraphInput(v *GetServiceGraphInput, value smithyjson.Value) error { 1181 object := value.Object() 1182 defer object.Close() 1183 1184 if v.EndTime != nil { 1185 ok := object.Key("EndTime") 1186 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime)) 1187 } 1188 1189 if v.GroupARN != nil { 1190 ok := object.Key("GroupARN") 1191 ok.String(*v.GroupARN) 1192 } 1193 1194 if v.GroupName != nil { 1195 ok := object.Key("GroupName") 1196 ok.String(*v.GroupName) 1197 } 1198 1199 if v.NextToken != nil { 1200 ok := object.Key("NextToken") 1201 ok.String(*v.NextToken) 1202 } 1203 1204 if v.StartTime != nil { 1205 ok := object.Key("StartTime") 1206 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime)) 1207 } 1208 1209 return nil 1210} 1211 1212type awsRestjson1_serializeOpGetTimeSeriesServiceStatistics struct { 1213} 1214 1215func (*awsRestjson1_serializeOpGetTimeSeriesServiceStatistics) ID() string { 1216 return "OperationSerializer" 1217} 1218 1219func (m *awsRestjson1_serializeOpGetTimeSeriesServiceStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1220 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1221) { 1222 request, ok := in.Request.(*smithyhttp.Request) 1223 if !ok { 1224 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1225 } 1226 1227 input, ok := in.Parameters.(*GetTimeSeriesServiceStatisticsInput) 1228 _ = input 1229 if !ok { 1230 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1231 } 1232 1233 opPath, opQuery := httpbinding.SplitURI("/TimeSeriesServiceStatistics") 1234 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1235 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1236 request.Method = "POST" 1237 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1238 if err != nil { 1239 return out, metadata, &smithy.SerializationError{Err: err} 1240 } 1241 1242 restEncoder.SetHeader("Content-Type").String("application/json") 1243 1244 jsonEncoder := smithyjson.NewEncoder() 1245 if err := awsRestjson1_serializeOpDocumentGetTimeSeriesServiceStatisticsInput(input, jsonEncoder.Value); err != nil { 1246 return out, metadata, &smithy.SerializationError{Err: err} 1247 } 1248 1249 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1250 return out, metadata, &smithy.SerializationError{Err: err} 1251 } 1252 1253 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1254 return out, metadata, &smithy.SerializationError{Err: err} 1255 } 1256 in.Request = request 1257 1258 return next.HandleSerialize(ctx, in) 1259} 1260func awsRestjson1_serializeOpHttpBindingsGetTimeSeriesServiceStatisticsInput(v *GetTimeSeriesServiceStatisticsInput, encoder *httpbinding.Encoder) error { 1261 if v == nil { 1262 return fmt.Errorf("unsupported serialization of nil %T", v) 1263 } 1264 1265 return nil 1266} 1267 1268func awsRestjson1_serializeOpDocumentGetTimeSeriesServiceStatisticsInput(v *GetTimeSeriesServiceStatisticsInput, value smithyjson.Value) error { 1269 object := value.Object() 1270 defer object.Close() 1271 1272 if v.EndTime != nil { 1273 ok := object.Key("EndTime") 1274 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime)) 1275 } 1276 1277 if v.EntitySelectorExpression != nil { 1278 ok := object.Key("EntitySelectorExpression") 1279 ok.String(*v.EntitySelectorExpression) 1280 } 1281 1282 if v.ForecastStatistics != nil { 1283 ok := object.Key("ForecastStatistics") 1284 ok.Boolean(*v.ForecastStatistics) 1285 } 1286 1287 if v.GroupARN != nil { 1288 ok := object.Key("GroupARN") 1289 ok.String(*v.GroupARN) 1290 } 1291 1292 if v.GroupName != nil { 1293 ok := object.Key("GroupName") 1294 ok.String(*v.GroupName) 1295 } 1296 1297 if v.NextToken != nil { 1298 ok := object.Key("NextToken") 1299 ok.String(*v.NextToken) 1300 } 1301 1302 if v.Period != nil { 1303 ok := object.Key("Period") 1304 ok.Integer(*v.Period) 1305 } 1306 1307 if v.StartTime != nil { 1308 ok := object.Key("StartTime") 1309 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime)) 1310 } 1311 1312 return nil 1313} 1314 1315type awsRestjson1_serializeOpGetTraceGraph struct { 1316} 1317 1318func (*awsRestjson1_serializeOpGetTraceGraph) ID() string { 1319 return "OperationSerializer" 1320} 1321 1322func (m *awsRestjson1_serializeOpGetTraceGraph) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1323 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1324) { 1325 request, ok := in.Request.(*smithyhttp.Request) 1326 if !ok { 1327 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1328 } 1329 1330 input, ok := in.Parameters.(*GetTraceGraphInput) 1331 _ = input 1332 if !ok { 1333 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1334 } 1335 1336 opPath, opQuery := httpbinding.SplitURI("/TraceGraph") 1337 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1338 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1339 request.Method = "POST" 1340 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1341 if err != nil { 1342 return out, metadata, &smithy.SerializationError{Err: err} 1343 } 1344 1345 restEncoder.SetHeader("Content-Type").String("application/json") 1346 1347 jsonEncoder := smithyjson.NewEncoder() 1348 if err := awsRestjson1_serializeOpDocumentGetTraceGraphInput(input, jsonEncoder.Value); err != nil { 1349 return out, metadata, &smithy.SerializationError{Err: err} 1350 } 1351 1352 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1353 return out, metadata, &smithy.SerializationError{Err: err} 1354 } 1355 1356 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1357 return out, metadata, &smithy.SerializationError{Err: err} 1358 } 1359 in.Request = request 1360 1361 return next.HandleSerialize(ctx, in) 1362} 1363func awsRestjson1_serializeOpHttpBindingsGetTraceGraphInput(v *GetTraceGraphInput, encoder *httpbinding.Encoder) error { 1364 if v == nil { 1365 return fmt.Errorf("unsupported serialization of nil %T", v) 1366 } 1367 1368 return nil 1369} 1370 1371func awsRestjson1_serializeOpDocumentGetTraceGraphInput(v *GetTraceGraphInput, value smithyjson.Value) error { 1372 object := value.Object() 1373 defer object.Close() 1374 1375 if v.NextToken != nil { 1376 ok := object.Key("NextToken") 1377 ok.String(*v.NextToken) 1378 } 1379 1380 if v.TraceIds != nil { 1381 ok := object.Key("TraceIds") 1382 if err := awsRestjson1_serializeDocumentTraceIdList(v.TraceIds, ok); err != nil { 1383 return err 1384 } 1385 } 1386 1387 return nil 1388} 1389 1390type awsRestjson1_serializeOpGetTraceSummaries struct { 1391} 1392 1393func (*awsRestjson1_serializeOpGetTraceSummaries) ID() string { 1394 return "OperationSerializer" 1395} 1396 1397func (m *awsRestjson1_serializeOpGetTraceSummaries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1398 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1399) { 1400 request, ok := in.Request.(*smithyhttp.Request) 1401 if !ok { 1402 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1403 } 1404 1405 input, ok := in.Parameters.(*GetTraceSummariesInput) 1406 _ = input 1407 if !ok { 1408 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1409 } 1410 1411 opPath, opQuery := httpbinding.SplitURI("/TraceSummaries") 1412 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1413 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1414 request.Method = "POST" 1415 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1416 if err != nil { 1417 return out, metadata, &smithy.SerializationError{Err: err} 1418 } 1419 1420 restEncoder.SetHeader("Content-Type").String("application/json") 1421 1422 jsonEncoder := smithyjson.NewEncoder() 1423 if err := awsRestjson1_serializeOpDocumentGetTraceSummariesInput(input, jsonEncoder.Value); err != nil { 1424 return out, metadata, &smithy.SerializationError{Err: err} 1425 } 1426 1427 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1428 return out, metadata, &smithy.SerializationError{Err: err} 1429 } 1430 1431 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1432 return out, metadata, &smithy.SerializationError{Err: err} 1433 } 1434 in.Request = request 1435 1436 return next.HandleSerialize(ctx, in) 1437} 1438func awsRestjson1_serializeOpHttpBindingsGetTraceSummariesInput(v *GetTraceSummariesInput, encoder *httpbinding.Encoder) error { 1439 if v == nil { 1440 return fmt.Errorf("unsupported serialization of nil %T", v) 1441 } 1442 1443 return nil 1444} 1445 1446func awsRestjson1_serializeOpDocumentGetTraceSummariesInput(v *GetTraceSummariesInput, value smithyjson.Value) error { 1447 object := value.Object() 1448 defer object.Close() 1449 1450 if v.EndTime != nil { 1451 ok := object.Key("EndTime") 1452 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime)) 1453 } 1454 1455 if v.FilterExpression != nil { 1456 ok := object.Key("FilterExpression") 1457 ok.String(*v.FilterExpression) 1458 } 1459 1460 if v.NextToken != nil { 1461 ok := object.Key("NextToken") 1462 ok.String(*v.NextToken) 1463 } 1464 1465 if v.Sampling != nil { 1466 ok := object.Key("Sampling") 1467 ok.Boolean(*v.Sampling) 1468 } 1469 1470 if v.SamplingStrategy != nil { 1471 ok := object.Key("SamplingStrategy") 1472 if err := awsRestjson1_serializeDocumentSamplingStrategy(v.SamplingStrategy, ok); err != nil { 1473 return err 1474 } 1475 } 1476 1477 if v.StartTime != nil { 1478 ok := object.Key("StartTime") 1479 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime)) 1480 } 1481 1482 if len(v.TimeRangeType) > 0 { 1483 ok := object.Key("TimeRangeType") 1484 ok.String(string(v.TimeRangeType)) 1485 } 1486 1487 return nil 1488} 1489 1490type awsRestjson1_serializeOpListTagsForResource struct { 1491} 1492 1493func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 1494 return "OperationSerializer" 1495} 1496 1497func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1498 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1499) { 1500 request, ok := in.Request.(*smithyhttp.Request) 1501 if !ok { 1502 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1503 } 1504 1505 input, ok := in.Parameters.(*ListTagsForResourceInput) 1506 _ = input 1507 if !ok { 1508 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1509 } 1510 1511 opPath, opQuery := httpbinding.SplitURI("/ListTagsForResource") 1512 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1513 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1514 request.Method = "POST" 1515 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1516 if err != nil { 1517 return out, metadata, &smithy.SerializationError{Err: err} 1518 } 1519 1520 restEncoder.SetHeader("Content-Type").String("application/json") 1521 1522 jsonEncoder := smithyjson.NewEncoder() 1523 if err := awsRestjson1_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil { 1524 return out, metadata, &smithy.SerializationError{Err: err} 1525 } 1526 1527 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1528 return out, metadata, &smithy.SerializationError{Err: err} 1529 } 1530 1531 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1532 return out, metadata, &smithy.SerializationError{Err: err} 1533 } 1534 in.Request = request 1535 1536 return next.HandleSerialize(ctx, in) 1537} 1538func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1539 if v == nil { 1540 return fmt.Errorf("unsupported serialization of nil %T", v) 1541 } 1542 1543 return nil 1544} 1545 1546func awsRestjson1_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error { 1547 object := value.Object() 1548 defer object.Close() 1549 1550 if v.NextToken != nil { 1551 ok := object.Key("NextToken") 1552 ok.String(*v.NextToken) 1553 } 1554 1555 if v.ResourceARN != nil { 1556 ok := object.Key("ResourceARN") 1557 ok.String(*v.ResourceARN) 1558 } 1559 1560 return nil 1561} 1562 1563type awsRestjson1_serializeOpPutEncryptionConfig struct { 1564} 1565 1566func (*awsRestjson1_serializeOpPutEncryptionConfig) ID() string { 1567 return "OperationSerializer" 1568} 1569 1570func (m *awsRestjson1_serializeOpPutEncryptionConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1571 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1572) { 1573 request, ok := in.Request.(*smithyhttp.Request) 1574 if !ok { 1575 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1576 } 1577 1578 input, ok := in.Parameters.(*PutEncryptionConfigInput) 1579 _ = input 1580 if !ok { 1581 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1582 } 1583 1584 opPath, opQuery := httpbinding.SplitURI("/PutEncryptionConfig") 1585 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1586 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1587 request.Method = "POST" 1588 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1589 if err != nil { 1590 return out, metadata, &smithy.SerializationError{Err: err} 1591 } 1592 1593 restEncoder.SetHeader("Content-Type").String("application/json") 1594 1595 jsonEncoder := smithyjson.NewEncoder() 1596 if err := awsRestjson1_serializeOpDocumentPutEncryptionConfigInput(input, jsonEncoder.Value); err != nil { 1597 return out, metadata, &smithy.SerializationError{Err: err} 1598 } 1599 1600 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1601 return out, metadata, &smithy.SerializationError{Err: err} 1602 } 1603 1604 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1605 return out, metadata, &smithy.SerializationError{Err: err} 1606 } 1607 in.Request = request 1608 1609 return next.HandleSerialize(ctx, in) 1610} 1611func awsRestjson1_serializeOpHttpBindingsPutEncryptionConfigInput(v *PutEncryptionConfigInput, encoder *httpbinding.Encoder) error { 1612 if v == nil { 1613 return fmt.Errorf("unsupported serialization of nil %T", v) 1614 } 1615 1616 return nil 1617} 1618 1619func awsRestjson1_serializeOpDocumentPutEncryptionConfigInput(v *PutEncryptionConfigInput, value smithyjson.Value) error { 1620 object := value.Object() 1621 defer object.Close() 1622 1623 if v.KeyId != nil { 1624 ok := object.Key("KeyId") 1625 ok.String(*v.KeyId) 1626 } 1627 1628 if len(v.Type) > 0 { 1629 ok := object.Key("Type") 1630 ok.String(string(v.Type)) 1631 } 1632 1633 return nil 1634} 1635 1636type awsRestjson1_serializeOpPutTelemetryRecords struct { 1637} 1638 1639func (*awsRestjson1_serializeOpPutTelemetryRecords) ID() string { 1640 return "OperationSerializer" 1641} 1642 1643func (m *awsRestjson1_serializeOpPutTelemetryRecords) 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.(*PutTelemetryRecordsInput) 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("/TelemetryRecords") 1658 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1659 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1660 request.Method = "POST" 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 restEncoder.SetHeader("Content-Type").String("application/json") 1667 1668 jsonEncoder := smithyjson.NewEncoder() 1669 if err := awsRestjson1_serializeOpDocumentPutTelemetryRecordsInput(input, jsonEncoder.Value); err != nil { 1670 return out, metadata, &smithy.SerializationError{Err: err} 1671 } 1672 1673 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1674 return out, metadata, &smithy.SerializationError{Err: err} 1675 } 1676 1677 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1678 return out, metadata, &smithy.SerializationError{Err: err} 1679 } 1680 in.Request = request 1681 1682 return next.HandleSerialize(ctx, in) 1683} 1684func awsRestjson1_serializeOpHttpBindingsPutTelemetryRecordsInput(v *PutTelemetryRecordsInput, encoder *httpbinding.Encoder) error { 1685 if v == nil { 1686 return fmt.Errorf("unsupported serialization of nil %T", v) 1687 } 1688 1689 return nil 1690} 1691 1692func awsRestjson1_serializeOpDocumentPutTelemetryRecordsInput(v *PutTelemetryRecordsInput, value smithyjson.Value) error { 1693 object := value.Object() 1694 defer object.Close() 1695 1696 if v.EC2InstanceId != nil { 1697 ok := object.Key("EC2InstanceId") 1698 ok.String(*v.EC2InstanceId) 1699 } 1700 1701 if v.Hostname != nil { 1702 ok := object.Key("Hostname") 1703 ok.String(*v.Hostname) 1704 } 1705 1706 if v.ResourceARN != nil { 1707 ok := object.Key("ResourceARN") 1708 ok.String(*v.ResourceARN) 1709 } 1710 1711 if v.TelemetryRecords != nil { 1712 ok := object.Key("TelemetryRecords") 1713 if err := awsRestjson1_serializeDocumentTelemetryRecordList(v.TelemetryRecords, ok); err != nil { 1714 return err 1715 } 1716 } 1717 1718 return nil 1719} 1720 1721type awsRestjson1_serializeOpPutTraceSegments struct { 1722} 1723 1724func (*awsRestjson1_serializeOpPutTraceSegments) ID() string { 1725 return "OperationSerializer" 1726} 1727 1728func (m *awsRestjson1_serializeOpPutTraceSegments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1729 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1730) { 1731 request, ok := in.Request.(*smithyhttp.Request) 1732 if !ok { 1733 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1734 } 1735 1736 input, ok := in.Parameters.(*PutTraceSegmentsInput) 1737 _ = input 1738 if !ok { 1739 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1740 } 1741 1742 opPath, opQuery := httpbinding.SplitURI("/TraceSegments") 1743 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1744 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1745 request.Method = "POST" 1746 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1747 if err != nil { 1748 return out, metadata, &smithy.SerializationError{Err: err} 1749 } 1750 1751 restEncoder.SetHeader("Content-Type").String("application/json") 1752 1753 jsonEncoder := smithyjson.NewEncoder() 1754 if err := awsRestjson1_serializeOpDocumentPutTraceSegmentsInput(input, jsonEncoder.Value); err != nil { 1755 return out, metadata, &smithy.SerializationError{Err: err} 1756 } 1757 1758 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1759 return out, metadata, &smithy.SerializationError{Err: err} 1760 } 1761 1762 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1763 return out, metadata, &smithy.SerializationError{Err: err} 1764 } 1765 in.Request = request 1766 1767 return next.HandleSerialize(ctx, in) 1768} 1769func awsRestjson1_serializeOpHttpBindingsPutTraceSegmentsInput(v *PutTraceSegmentsInput, encoder *httpbinding.Encoder) error { 1770 if v == nil { 1771 return fmt.Errorf("unsupported serialization of nil %T", v) 1772 } 1773 1774 return nil 1775} 1776 1777func awsRestjson1_serializeOpDocumentPutTraceSegmentsInput(v *PutTraceSegmentsInput, value smithyjson.Value) error { 1778 object := value.Object() 1779 defer object.Close() 1780 1781 if v.TraceSegmentDocuments != nil { 1782 ok := object.Key("TraceSegmentDocuments") 1783 if err := awsRestjson1_serializeDocumentTraceSegmentDocumentList(v.TraceSegmentDocuments, ok); err != nil { 1784 return err 1785 } 1786 } 1787 1788 return nil 1789} 1790 1791type awsRestjson1_serializeOpTagResource struct { 1792} 1793 1794func (*awsRestjson1_serializeOpTagResource) ID() string { 1795 return "OperationSerializer" 1796} 1797 1798func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1799 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1800) { 1801 request, ok := in.Request.(*smithyhttp.Request) 1802 if !ok { 1803 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1804 } 1805 1806 input, ok := in.Parameters.(*TagResourceInput) 1807 _ = input 1808 if !ok { 1809 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1810 } 1811 1812 opPath, opQuery := httpbinding.SplitURI("/TagResource") 1813 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1814 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1815 request.Method = "POST" 1816 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1817 if err != nil { 1818 return out, metadata, &smithy.SerializationError{Err: err} 1819 } 1820 1821 restEncoder.SetHeader("Content-Type").String("application/json") 1822 1823 jsonEncoder := smithyjson.NewEncoder() 1824 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 1825 return out, metadata, &smithy.SerializationError{Err: err} 1826 } 1827 1828 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1829 return out, metadata, &smithy.SerializationError{Err: err} 1830 } 1831 1832 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1833 return out, metadata, &smithy.SerializationError{Err: err} 1834 } 1835 in.Request = request 1836 1837 return next.HandleSerialize(ctx, in) 1838} 1839func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 1840 if v == nil { 1841 return fmt.Errorf("unsupported serialization of nil %T", v) 1842 } 1843 1844 return nil 1845} 1846 1847func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 1848 object := value.Object() 1849 defer object.Close() 1850 1851 if v.ResourceARN != nil { 1852 ok := object.Key("ResourceARN") 1853 ok.String(*v.ResourceARN) 1854 } 1855 1856 if v.Tags != nil { 1857 ok := object.Key("Tags") 1858 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 1859 return err 1860 } 1861 } 1862 1863 return nil 1864} 1865 1866type awsRestjson1_serializeOpUntagResource struct { 1867} 1868 1869func (*awsRestjson1_serializeOpUntagResource) ID() string { 1870 return "OperationSerializer" 1871} 1872 1873func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1874 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1875) { 1876 request, ok := in.Request.(*smithyhttp.Request) 1877 if !ok { 1878 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1879 } 1880 1881 input, ok := in.Parameters.(*UntagResourceInput) 1882 _ = input 1883 if !ok { 1884 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1885 } 1886 1887 opPath, opQuery := httpbinding.SplitURI("/UntagResource") 1888 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1889 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1890 request.Method = "POST" 1891 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1892 if err != nil { 1893 return out, metadata, &smithy.SerializationError{Err: err} 1894 } 1895 1896 restEncoder.SetHeader("Content-Type").String("application/json") 1897 1898 jsonEncoder := smithyjson.NewEncoder() 1899 if err := awsRestjson1_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil { 1900 return out, metadata, &smithy.SerializationError{Err: err} 1901 } 1902 1903 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1904 return out, metadata, &smithy.SerializationError{Err: err} 1905 } 1906 1907 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1908 return out, metadata, &smithy.SerializationError{Err: err} 1909 } 1910 in.Request = request 1911 1912 return next.HandleSerialize(ctx, in) 1913} 1914func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 1915 if v == nil { 1916 return fmt.Errorf("unsupported serialization of nil %T", v) 1917 } 1918 1919 return nil 1920} 1921 1922func awsRestjson1_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error { 1923 object := value.Object() 1924 defer object.Close() 1925 1926 if v.ResourceARN != nil { 1927 ok := object.Key("ResourceARN") 1928 ok.String(*v.ResourceARN) 1929 } 1930 1931 if v.TagKeys != nil { 1932 ok := object.Key("TagKeys") 1933 if err := awsRestjson1_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil { 1934 return err 1935 } 1936 } 1937 1938 return nil 1939} 1940 1941type awsRestjson1_serializeOpUpdateGroup struct { 1942} 1943 1944func (*awsRestjson1_serializeOpUpdateGroup) ID() string { 1945 return "OperationSerializer" 1946} 1947 1948func (m *awsRestjson1_serializeOpUpdateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1949 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1950) { 1951 request, ok := in.Request.(*smithyhttp.Request) 1952 if !ok { 1953 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1954 } 1955 1956 input, ok := in.Parameters.(*UpdateGroupInput) 1957 _ = input 1958 if !ok { 1959 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1960 } 1961 1962 opPath, opQuery := httpbinding.SplitURI("/UpdateGroup") 1963 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1964 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1965 request.Method = "POST" 1966 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1967 if err != nil { 1968 return out, metadata, &smithy.SerializationError{Err: err} 1969 } 1970 1971 restEncoder.SetHeader("Content-Type").String("application/json") 1972 1973 jsonEncoder := smithyjson.NewEncoder() 1974 if err := awsRestjson1_serializeOpDocumentUpdateGroupInput(input, jsonEncoder.Value); err != nil { 1975 return out, metadata, &smithy.SerializationError{Err: err} 1976 } 1977 1978 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1979 return out, metadata, &smithy.SerializationError{Err: err} 1980 } 1981 1982 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1983 return out, metadata, &smithy.SerializationError{Err: err} 1984 } 1985 in.Request = request 1986 1987 return next.HandleSerialize(ctx, in) 1988} 1989func awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(v *UpdateGroupInput, encoder *httpbinding.Encoder) error { 1990 if v == nil { 1991 return fmt.Errorf("unsupported serialization of nil %T", v) 1992 } 1993 1994 return nil 1995} 1996 1997func awsRestjson1_serializeOpDocumentUpdateGroupInput(v *UpdateGroupInput, value smithyjson.Value) error { 1998 object := value.Object() 1999 defer object.Close() 2000 2001 if v.FilterExpression != nil { 2002 ok := object.Key("FilterExpression") 2003 ok.String(*v.FilterExpression) 2004 } 2005 2006 if v.GroupARN != nil { 2007 ok := object.Key("GroupARN") 2008 ok.String(*v.GroupARN) 2009 } 2010 2011 if v.GroupName != nil { 2012 ok := object.Key("GroupName") 2013 ok.String(*v.GroupName) 2014 } 2015 2016 if v.InsightsConfiguration != nil { 2017 ok := object.Key("InsightsConfiguration") 2018 if err := awsRestjson1_serializeDocumentInsightsConfiguration(v.InsightsConfiguration, ok); err != nil { 2019 return err 2020 } 2021 } 2022 2023 return nil 2024} 2025 2026type awsRestjson1_serializeOpUpdateSamplingRule struct { 2027} 2028 2029func (*awsRestjson1_serializeOpUpdateSamplingRule) ID() string { 2030 return "OperationSerializer" 2031} 2032 2033func (m *awsRestjson1_serializeOpUpdateSamplingRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2034 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2035) { 2036 request, ok := in.Request.(*smithyhttp.Request) 2037 if !ok { 2038 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2039 } 2040 2041 input, ok := in.Parameters.(*UpdateSamplingRuleInput) 2042 _ = input 2043 if !ok { 2044 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2045 } 2046 2047 opPath, opQuery := httpbinding.SplitURI("/UpdateSamplingRule") 2048 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2049 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2050 request.Method = "POST" 2051 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2052 if err != nil { 2053 return out, metadata, &smithy.SerializationError{Err: err} 2054 } 2055 2056 restEncoder.SetHeader("Content-Type").String("application/json") 2057 2058 jsonEncoder := smithyjson.NewEncoder() 2059 if err := awsRestjson1_serializeOpDocumentUpdateSamplingRuleInput(input, jsonEncoder.Value); err != nil { 2060 return out, metadata, &smithy.SerializationError{Err: err} 2061 } 2062 2063 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2064 return out, metadata, &smithy.SerializationError{Err: err} 2065 } 2066 2067 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2068 return out, metadata, &smithy.SerializationError{Err: err} 2069 } 2070 in.Request = request 2071 2072 return next.HandleSerialize(ctx, in) 2073} 2074func awsRestjson1_serializeOpHttpBindingsUpdateSamplingRuleInput(v *UpdateSamplingRuleInput, encoder *httpbinding.Encoder) error { 2075 if v == nil { 2076 return fmt.Errorf("unsupported serialization of nil %T", v) 2077 } 2078 2079 return nil 2080} 2081 2082func awsRestjson1_serializeOpDocumentUpdateSamplingRuleInput(v *UpdateSamplingRuleInput, value smithyjson.Value) error { 2083 object := value.Object() 2084 defer object.Close() 2085 2086 if v.SamplingRuleUpdate != nil { 2087 ok := object.Key("SamplingRuleUpdate") 2088 if err := awsRestjson1_serializeDocumentSamplingRuleUpdate(v.SamplingRuleUpdate, ok); err != nil { 2089 return err 2090 } 2091 } 2092 2093 return nil 2094} 2095 2096func awsRestjson1_serializeDocumentAttributeMap(v map[string]string, value smithyjson.Value) error { 2097 object := value.Object() 2098 defer object.Close() 2099 2100 for key := range v { 2101 om := object.Key(key) 2102 om.String(v[key]) 2103 } 2104 return nil 2105} 2106 2107func awsRestjson1_serializeDocumentBackendConnectionErrors(v *types.BackendConnectionErrors, value smithyjson.Value) error { 2108 object := value.Object() 2109 defer object.Close() 2110 2111 if v.ConnectionRefusedCount != nil { 2112 ok := object.Key("ConnectionRefusedCount") 2113 ok.Integer(*v.ConnectionRefusedCount) 2114 } 2115 2116 if v.HTTPCode4XXCount != nil { 2117 ok := object.Key("HTTPCode4XXCount") 2118 ok.Integer(*v.HTTPCode4XXCount) 2119 } 2120 2121 if v.HTTPCode5XXCount != nil { 2122 ok := object.Key("HTTPCode5XXCount") 2123 ok.Integer(*v.HTTPCode5XXCount) 2124 } 2125 2126 if v.OtherCount != nil { 2127 ok := object.Key("OtherCount") 2128 ok.Integer(*v.OtherCount) 2129 } 2130 2131 if v.TimeoutCount != nil { 2132 ok := object.Key("TimeoutCount") 2133 ok.Integer(*v.TimeoutCount) 2134 } 2135 2136 if v.UnknownHostCount != nil { 2137 ok := object.Key("UnknownHostCount") 2138 ok.Integer(*v.UnknownHostCount) 2139 } 2140 2141 return nil 2142} 2143 2144func awsRestjson1_serializeDocumentInsightsConfiguration(v *types.InsightsConfiguration, value smithyjson.Value) error { 2145 object := value.Object() 2146 defer object.Close() 2147 2148 if v.InsightsEnabled != nil { 2149 ok := object.Key("InsightsEnabled") 2150 ok.Boolean(*v.InsightsEnabled) 2151 } 2152 2153 if v.NotificationsEnabled != nil { 2154 ok := object.Key("NotificationsEnabled") 2155 ok.Boolean(*v.NotificationsEnabled) 2156 } 2157 2158 return nil 2159} 2160 2161func awsRestjson1_serializeDocumentInsightStateList(v []types.InsightState, value smithyjson.Value) error { 2162 array := value.Array() 2163 defer array.Close() 2164 2165 for i := range v { 2166 av := array.Value() 2167 av.String(string(v[i])) 2168 } 2169 return nil 2170} 2171 2172func awsRestjson1_serializeDocumentSamplingRule(v *types.SamplingRule, value smithyjson.Value) error { 2173 object := value.Object() 2174 defer object.Close() 2175 2176 if v.Attributes != nil { 2177 ok := object.Key("Attributes") 2178 if err := awsRestjson1_serializeDocumentAttributeMap(v.Attributes, ok); err != nil { 2179 return err 2180 } 2181 } 2182 2183 { 2184 ok := object.Key("FixedRate") 2185 ok.Double(v.FixedRate) 2186 } 2187 2188 if v.Host != nil { 2189 ok := object.Key("Host") 2190 ok.String(*v.Host) 2191 } 2192 2193 if v.HTTPMethod != nil { 2194 ok := object.Key("HTTPMethod") 2195 ok.String(*v.HTTPMethod) 2196 } 2197 2198 { 2199 ok := object.Key("Priority") 2200 ok.Integer(v.Priority) 2201 } 2202 2203 { 2204 ok := object.Key("ReservoirSize") 2205 ok.Integer(v.ReservoirSize) 2206 } 2207 2208 if v.ResourceARN != nil { 2209 ok := object.Key("ResourceARN") 2210 ok.String(*v.ResourceARN) 2211 } 2212 2213 if v.RuleARN != nil { 2214 ok := object.Key("RuleARN") 2215 ok.String(*v.RuleARN) 2216 } 2217 2218 if v.RuleName != nil { 2219 ok := object.Key("RuleName") 2220 ok.String(*v.RuleName) 2221 } 2222 2223 if v.ServiceName != nil { 2224 ok := object.Key("ServiceName") 2225 ok.String(*v.ServiceName) 2226 } 2227 2228 if v.ServiceType != nil { 2229 ok := object.Key("ServiceType") 2230 ok.String(*v.ServiceType) 2231 } 2232 2233 if v.URLPath != nil { 2234 ok := object.Key("URLPath") 2235 ok.String(*v.URLPath) 2236 } 2237 2238 { 2239 ok := object.Key("Version") 2240 ok.Integer(v.Version) 2241 } 2242 2243 return nil 2244} 2245 2246func awsRestjson1_serializeDocumentSamplingRuleUpdate(v *types.SamplingRuleUpdate, value smithyjson.Value) error { 2247 object := value.Object() 2248 defer object.Close() 2249 2250 if v.Attributes != nil { 2251 ok := object.Key("Attributes") 2252 if err := awsRestjson1_serializeDocumentAttributeMap(v.Attributes, ok); err != nil { 2253 return err 2254 } 2255 } 2256 2257 if v.FixedRate != nil { 2258 ok := object.Key("FixedRate") 2259 ok.Double(*v.FixedRate) 2260 } 2261 2262 if v.Host != nil { 2263 ok := object.Key("Host") 2264 ok.String(*v.Host) 2265 } 2266 2267 if v.HTTPMethod != nil { 2268 ok := object.Key("HTTPMethod") 2269 ok.String(*v.HTTPMethod) 2270 } 2271 2272 if v.Priority != nil { 2273 ok := object.Key("Priority") 2274 ok.Integer(*v.Priority) 2275 } 2276 2277 if v.ReservoirSize != nil { 2278 ok := object.Key("ReservoirSize") 2279 ok.Integer(*v.ReservoirSize) 2280 } 2281 2282 if v.ResourceARN != nil { 2283 ok := object.Key("ResourceARN") 2284 ok.String(*v.ResourceARN) 2285 } 2286 2287 if v.RuleARN != nil { 2288 ok := object.Key("RuleARN") 2289 ok.String(*v.RuleARN) 2290 } 2291 2292 if v.RuleName != nil { 2293 ok := object.Key("RuleName") 2294 ok.String(*v.RuleName) 2295 } 2296 2297 if v.ServiceName != nil { 2298 ok := object.Key("ServiceName") 2299 ok.String(*v.ServiceName) 2300 } 2301 2302 if v.ServiceType != nil { 2303 ok := object.Key("ServiceType") 2304 ok.String(*v.ServiceType) 2305 } 2306 2307 if v.URLPath != nil { 2308 ok := object.Key("URLPath") 2309 ok.String(*v.URLPath) 2310 } 2311 2312 return nil 2313} 2314 2315func awsRestjson1_serializeDocumentSamplingStatisticsDocument(v *types.SamplingStatisticsDocument, value smithyjson.Value) error { 2316 object := value.Object() 2317 defer object.Close() 2318 2319 if v.BorrowCount != 0 { 2320 ok := object.Key("BorrowCount") 2321 ok.Integer(v.BorrowCount) 2322 } 2323 2324 if v.ClientID != nil { 2325 ok := object.Key("ClientID") 2326 ok.String(*v.ClientID) 2327 } 2328 2329 { 2330 ok := object.Key("RequestCount") 2331 ok.Integer(v.RequestCount) 2332 } 2333 2334 if v.RuleName != nil { 2335 ok := object.Key("RuleName") 2336 ok.String(*v.RuleName) 2337 } 2338 2339 { 2340 ok := object.Key("SampledCount") 2341 ok.Integer(v.SampledCount) 2342 } 2343 2344 if v.Timestamp != nil { 2345 ok := object.Key("Timestamp") 2346 ok.Double(smithytime.FormatEpochSeconds(*v.Timestamp)) 2347 } 2348 2349 return nil 2350} 2351 2352func awsRestjson1_serializeDocumentSamplingStatisticsDocumentList(v []types.SamplingStatisticsDocument, value smithyjson.Value) error { 2353 array := value.Array() 2354 defer array.Close() 2355 2356 for i := range v { 2357 av := array.Value() 2358 if err := awsRestjson1_serializeDocumentSamplingStatisticsDocument(&v[i], av); err != nil { 2359 return err 2360 } 2361 } 2362 return nil 2363} 2364 2365func awsRestjson1_serializeDocumentSamplingStrategy(v *types.SamplingStrategy, value smithyjson.Value) error { 2366 object := value.Object() 2367 defer object.Close() 2368 2369 if len(v.Name) > 0 { 2370 ok := object.Key("Name") 2371 ok.String(string(v.Name)) 2372 } 2373 2374 if v.Value != nil { 2375 ok := object.Key("Value") 2376 ok.Double(*v.Value) 2377 } 2378 2379 return nil 2380} 2381 2382func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 2383 object := value.Object() 2384 defer object.Close() 2385 2386 if v.Key != nil { 2387 ok := object.Key("Key") 2388 ok.String(*v.Key) 2389 } 2390 2391 if v.Value != nil { 2392 ok := object.Key("Value") 2393 ok.String(*v.Value) 2394 } 2395 2396 return nil 2397} 2398 2399func awsRestjson1_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error { 2400 array := value.Array() 2401 defer array.Close() 2402 2403 for i := range v { 2404 av := array.Value() 2405 av.String(v[i]) 2406 } 2407 return nil 2408} 2409 2410func awsRestjson1_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error { 2411 array := value.Array() 2412 defer array.Close() 2413 2414 for i := range v { 2415 av := array.Value() 2416 if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil { 2417 return err 2418 } 2419 } 2420 return nil 2421} 2422 2423func awsRestjson1_serializeDocumentTelemetryRecord(v *types.TelemetryRecord, value smithyjson.Value) error { 2424 object := value.Object() 2425 defer object.Close() 2426 2427 if v.BackendConnectionErrors != nil { 2428 ok := object.Key("BackendConnectionErrors") 2429 if err := awsRestjson1_serializeDocumentBackendConnectionErrors(v.BackendConnectionErrors, ok); err != nil { 2430 return err 2431 } 2432 } 2433 2434 if v.SegmentsReceivedCount != nil { 2435 ok := object.Key("SegmentsReceivedCount") 2436 ok.Integer(*v.SegmentsReceivedCount) 2437 } 2438 2439 if v.SegmentsRejectedCount != nil { 2440 ok := object.Key("SegmentsRejectedCount") 2441 ok.Integer(*v.SegmentsRejectedCount) 2442 } 2443 2444 if v.SegmentsSentCount != nil { 2445 ok := object.Key("SegmentsSentCount") 2446 ok.Integer(*v.SegmentsSentCount) 2447 } 2448 2449 if v.SegmentsSpilloverCount != nil { 2450 ok := object.Key("SegmentsSpilloverCount") 2451 ok.Integer(*v.SegmentsSpilloverCount) 2452 } 2453 2454 if v.Timestamp != nil { 2455 ok := object.Key("Timestamp") 2456 ok.Double(smithytime.FormatEpochSeconds(*v.Timestamp)) 2457 } 2458 2459 return nil 2460} 2461 2462func awsRestjson1_serializeDocumentTelemetryRecordList(v []types.TelemetryRecord, value smithyjson.Value) error { 2463 array := value.Array() 2464 defer array.Close() 2465 2466 for i := range v { 2467 av := array.Value() 2468 if err := awsRestjson1_serializeDocumentTelemetryRecord(&v[i], av); err != nil { 2469 return err 2470 } 2471 } 2472 return nil 2473} 2474 2475func awsRestjson1_serializeDocumentTraceIdList(v []string, value smithyjson.Value) error { 2476 array := value.Array() 2477 defer array.Close() 2478 2479 for i := range v { 2480 av := array.Value() 2481 av.String(v[i]) 2482 } 2483 return nil 2484} 2485 2486func awsRestjson1_serializeDocumentTraceSegmentDocumentList(v []string, value smithyjson.Value) error { 2487 array := value.Array() 2488 defer array.Close() 2489 2490 for i := range v { 2491 av := array.Value() 2492 av.String(v[i]) 2493 } 2494 return nil 2495} 2496