1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package lookoutmetrics 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/lookoutmetrics/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsRestjson1_serializeOpActivateAnomalyDetector struct { 18} 19 20func (*awsRestjson1_serializeOpActivateAnomalyDetector) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpActivateAnomalyDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 25 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 26) { 27 request, ok := in.Request.(*smithyhttp.Request) 28 if !ok { 29 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 30 } 31 32 input, ok := in.Parameters.(*ActivateAnomalyDetectorInput) 33 _ = input 34 if !ok { 35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 36 } 37 38 opPath, opQuery := httpbinding.SplitURI("/ActivateAnomalyDetector") 39 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 40 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 41 request.Method = "POST" 42 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 43 if err != nil { 44 return out, metadata, &smithy.SerializationError{Err: err} 45 } 46 47 restEncoder.SetHeader("Content-Type").String("application/json") 48 49 jsonEncoder := smithyjson.NewEncoder() 50 if err := awsRestjson1_serializeOpDocumentActivateAnomalyDetectorInput(input, jsonEncoder.Value); err != nil { 51 return out, metadata, &smithy.SerializationError{Err: err} 52 } 53 54 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 55 return out, metadata, &smithy.SerializationError{Err: err} 56 } 57 58 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 59 return out, metadata, &smithy.SerializationError{Err: err} 60 } 61 in.Request = request 62 63 return next.HandleSerialize(ctx, in) 64} 65func awsRestjson1_serializeOpHttpBindingsActivateAnomalyDetectorInput(v *ActivateAnomalyDetectorInput, encoder *httpbinding.Encoder) error { 66 if v == nil { 67 return fmt.Errorf("unsupported serialization of nil %T", v) 68 } 69 70 return nil 71} 72 73func awsRestjson1_serializeOpDocumentActivateAnomalyDetectorInput(v *ActivateAnomalyDetectorInput, value smithyjson.Value) error { 74 object := value.Object() 75 defer object.Close() 76 77 if v.AnomalyDetectorArn != nil { 78 ok := object.Key("AnomalyDetectorArn") 79 ok.String(*v.AnomalyDetectorArn) 80 } 81 82 return nil 83} 84 85type awsRestjson1_serializeOpBackTestAnomalyDetector struct { 86} 87 88func (*awsRestjson1_serializeOpBackTestAnomalyDetector) ID() string { 89 return "OperationSerializer" 90} 91 92func (m *awsRestjson1_serializeOpBackTestAnomalyDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 93 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 94) { 95 request, ok := in.Request.(*smithyhttp.Request) 96 if !ok { 97 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 98 } 99 100 input, ok := in.Parameters.(*BackTestAnomalyDetectorInput) 101 _ = input 102 if !ok { 103 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 104 } 105 106 opPath, opQuery := httpbinding.SplitURI("/BackTestAnomalyDetector") 107 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 108 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 109 request.Method = "POST" 110 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 111 if err != nil { 112 return out, metadata, &smithy.SerializationError{Err: err} 113 } 114 115 restEncoder.SetHeader("Content-Type").String("application/json") 116 117 jsonEncoder := smithyjson.NewEncoder() 118 if err := awsRestjson1_serializeOpDocumentBackTestAnomalyDetectorInput(input, jsonEncoder.Value); err != nil { 119 return out, metadata, &smithy.SerializationError{Err: err} 120 } 121 122 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 123 return out, metadata, &smithy.SerializationError{Err: err} 124 } 125 126 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 127 return out, metadata, &smithy.SerializationError{Err: err} 128 } 129 in.Request = request 130 131 return next.HandleSerialize(ctx, in) 132} 133func awsRestjson1_serializeOpHttpBindingsBackTestAnomalyDetectorInput(v *BackTestAnomalyDetectorInput, encoder *httpbinding.Encoder) error { 134 if v == nil { 135 return fmt.Errorf("unsupported serialization of nil %T", v) 136 } 137 138 return nil 139} 140 141func awsRestjson1_serializeOpDocumentBackTestAnomalyDetectorInput(v *BackTestAnomalyDetectorInput, value smithyjson.Value) error { 142 object := value.Object() 143 defer object.Close() 144 145 if v.AnomalyDetectorArn != nil { 146 ok := object.Key("AnomalyDetectorArn") 147 ok.String(*v.AnomalyDetectorArn) 148 } 149 150 return nil 151} 152 153type awsRestjson1_serializeOpCreateAlert struct { 154} 155 156func (*awsRestjson1_serializeOpCreateAlert) ID() string { 157 return "OperationSerializer" 158} 159 160func (m *awsRestjson1_serializeOpCreateAlert) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 161 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 162) { 163 request, ok := in.Request.(*smithyhttp.Request) 164 if !ok { 165 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 166 } 167 168 input, ok := in.Parameters.(*CreateAlertInput) 169 _ = input 170 if !ok { 171 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 172 } 173 174 opPath, opQuery := httpbinding.SplitURI("/CreateAlert") 175 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 176 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 177 request.Method = "POST" 178 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 179 if err != nil { 180 return out, metadata, &smithy.SerializationError{Err: err} 181 } 182 183 restEncoder.SetHeader("Content-Type").String("application/json") 184 185 jsonEncoder := smithyjson.NewEncoder() 186 if err := awsRestjson1_serializeOpDocumentCreateAlertInput(input, jsonEncoder.Value); err != nil { 187 return out, metadata, &smithy.SerializationError{Err: err} 188 } 189 190 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 191 return out, metadata, &smithy.SerializationError{Err: err} 192 } 193 194 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 195 return out, metadata, &smithy.SerializationError{Err: err} 196 } 197 in.Request = request 198 199 return next.HandleSerialize(ctx, in) 200} 201func awsRestjson1_serializeOpHttpBindingsCreateAlertInput(v *CreateAlertInput, encoder *httpbinding.Encoder) error { 202 if v == nil { 203 return fmt.Errorf("unsupported serialization of nil %T", v) 204 } 205 206 return nil 207} 208 209func awsRestjson1_serializeOpDocumentCreateAlertInput(v *CreateAlertInput, value smithyjson.Value) error { 210 object := value.Object() 211 defer object.Close() 212 213 if v.Action != nil { 214 ok := object.Key("Action") 215 if err := awsRestjson1_serializeDocumentAction(v.Action, ok); err != nil { 216 return err 217 } 218 } 219 220 if v.AlertDescription != nil { 221 ok := object.Key("AlertDescription") 222 ok.String(*v.AlertDescription) 223 } 224 225 if v.AlertName != nil { 226 ok := object.Key("AlertName") 227 ok.String(*v.AlertName) 228 } 229 230 { 231 ok := object.Key("AlertSensitivityThreshold") 232 ok.Integer(v.AlertSensitivityThreshold) 233 } 234 235 if v.AnomalyDetectorArn != nil { 236 ok := object.Key("AnomalyDetectorArn") 237 ok.String(*v.AnomalyDetectorArn) 238 } 239 240 if v.Tags != nil { 241 ok := object.Key("Tags") 242 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 243 return err 244 } 245 } 246 247 return nil 248} 249 250type awsRestjson1_serializeOpCreateAnomalyDetector struct { 251} 252 253func (*awsRestjson1_serializeOpCreateAnomalyDetector) ID() string { 254 return "OperationSerializer" 255} 256 257func (m *awsRestjson1_serializeOpCreateAnomalyDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 258 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 259) { 260 request, ok := in.Request.(*smithyhttp.Request) 261 if !ok { 262 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 263 } 264 265 input, ok := in.Parameters.(*CreateAnomalyDetectorInput) 266 _ = input 267 if !ok { 268 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 269 } 270 271 opPath, opQuery := httpbinding.SplitURI("/CreateAnomalyDetector") 272 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 273 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 274 request.Method = "POST" 275 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 276 if err != nil { 277 return out, metadata, &smithy.SerializationError{Err: err} 278 } 279 280 restEncoder.SetHeader("Content-Type").String("application/json") 281 282 jsonEncoder := smithyjson.NewEncoder() 283 if err := awsRestjson1_serializeOpDocumentCreateAnomalyDetectorInput(input, jsonEncoder.Value); err != nil { 284 return out, metadata, &smithy.SerializationError{Err: err} 285 } 286 287 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 288 return out, metadata, &smithy.SerializationError{Err: err} 289 } 290 291 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 292 return out, metadata, &smithy.SerializationError{Err: err} 293 } 294 in.Request = request 295 296 return next.HandleSerialize(ctx, in) 297} 298func awsRestjson1_serializeOpHttpBindingsCreateAnomalyDetectorInput(v *CreateAnomalyDetectorInput, encoder *httpbinding.Encoder) error { 299 if v == nil { 300 return fmt.Errorf("unsupported serialization of nil %T", v) 301 } 302 303 return nil 304} 305 306func awsRestjson1_serializeOpDocumentCreateAnomalyDetectorInput(v *CreateAnomalyDetectorInput, value smithyjson.Value) error { 307 object := value.Object() 308 defer object.Close() 309 310 if v.AnomalyDetectorConfig != nil { 311 ok := object.Key("AnomalyDetectorConfig") 312 if err := awsRestjson1_serializeDocumentAnomalyDetectorConfig(v.AnomalyDetectorConfig, ok); err != nil { 313 return err 314 } 315 } 316 317 if v.AnomalyDetectorDescription != nil { 318 ok := object.Key("AnomalyDetectorDescription") 319 ok.String(*v.AnomalyDetectorDescription) 320 } 321 322 if v.AnomalyDetectorName != nil { 323 ok := object.Key("AnomalyDetectorName") 324 ok.String(*v.AnomalyDetectorName) 325 } 326 327 if v.KmsKeyArn != nil { 328 ok := object.Key("KmsKeyArn") 329 ok.String(*v.KmsKeyArn) 330 } 331 332 if v.Tags != nil { 333 ok := object.Key("Tags") 334 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 335 return err 336 } 337 } 338 339 return nil 340} 341 342type awsRestjson1_serializeOpCreateMetricSet struct { 343} 344 345func (*awsRestjson1_serializeOpCreateMetricSet) ID() string { 346 return "OperationSerializer" 347} 348 349func (m *awsRestjson1_serializeOpCreateMetricSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 350 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 351) { 352 request, ok := in.Request.(*smithyhttp.Request) 353 if !ok { 354 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 355 } 356 357 input, ok := in.Parameters.(*CreateMetricSetInput) 358 _ = input 359 if !ok { 360 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 361 } 362 363 opPath, opQuery := httpbinding.SplitURI("/CreateMetricSet") 364 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 365 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 366 request.Method = "POST" 367 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 368 if err != nil { 369 return out, metadata, &smithy.SerializationError{Err: err} 370 } 371 372 restEncoder.SetHeader("Content-Type").String("application/json") 373 374 jsonEncoder := smithyjson.NewEncoder() 375 if err := awsRestjson1_serializeOpDocumentCreateMetricSetInput(input, jsonEncoder.Value); err != nil { 376 return out, metadata, &smithy.SerializationError{Err: err} 377 } 378 379 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 380 return out, metadata, &smithy.SerializationError{Err: err} 381 } 382 383 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 384 return out, metadata, &smithy.SerializationError{Err: err} 385 } 386 in.Request = request 387 388 return next.HandleSerialize(ctx, in) 389} 390func awsRestjson1_serializeOpHttpBindingsCreateMetricSetInput(v *CreateMetricSetInput, encoder *httpbinding.Encoder) error { 391 if v == nil { 392 return fmt.Errorf("unsupported serialization of nil %T", v) 393 } 394 395 return nil 396} 397 398func awsRestjson1_serializeOpDocumentCreateMetricSetInput(v *CreateMetricSetInput, value smithyjson.Value) error { 399 object := value.Object() 400 defer object.Close() 401 402 if v.AnomalyDetectorArn != nil { 403 ok := object.Key("AnomalyDetectorArn") 404 ok.String(*v.AnomalyDetectorArn) 405 } 406 407 if v.DimensionList != nil { 408 ok := object.Key("DimensionList") 409 if err := awsRestjson1_serializeDocumentDimensionList(v.DimensionList, ok); err != nil { 410 return err 411 } 412 } 413 414 if v.MetricList != nil { 415 ok := object.Key("MetricList") 416 if err := awsRestjson1_serializeDocumentMetricList(v.MetricList, ok); err != nil { 417 return err 418 } 419 } 420 421 if v.MetricSetDescription != nil { 422 ok := object.Key("MetricSetDescription") 423 ok.String(*v.MetricSetDescription) 424 } 425 426 if len(v.MetricSetFrequency) > 0 { 427 ok := object.Key("MetricSetFrequency") 428 ok.String(string(v.MetricSetFrequency)) 429 } 430 431 if v.MetricSetName != nil { 432 ok := object.Key("MetricSetName") 433 ok.String(*v.MetricSetName) 434 } 435 436 if v.MetricSource != nil { 437 ok := object.Key("MetricSource") 438 if err := awsRestjson1_serializeDocumentMetricSource(v.MetricSource, ok); err != nil { 439 return err 440 } 441 } 442 443 if v.Offset != 0 { 444 ok := object.Key("Offset") 445 ok.Integer(v.Offset) 446 } 447 448 if v.Tags != nil { 449 ok := object.Key("Tags") 450 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 451 return err 452 } 453 } 454 455 if v.TimestampColumn != nil { 456 ok := object.Key("TimestampColumn") 457 if err := awsRestjson1_serializeDocumentTimestampColumn(v.TimestampColumn, ok); err != nil { 458 return err 459 } 460 } 461 462 if v.Timezone != nil { 463 ok := object.Key("Timezone") 464 ok.String(*v.Timezone) 465 } 466 467 return nil 468} 469 470type awsRestjson1_serializeOpDeleteAlert struct { 471} 472 473func (*awsRestjson1_serializeOpDeleteAlert) ID() string { 474 return "OperationSerializer" 475} 476 477func (m *awsRestjson1_serializeOpDeleteAlert) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 478 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 479) { 480 request, ok := in.Request.(*smithyhttp.Request) 481 if !ok { 482 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 483 } 484 485 input, ok := in.Parameters.(*DeleteAlertInput) 486 _ = input 487 if !ok { 488 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 489 } 490 491 opPath, opQuery := httpbinding.SplitURI("/DeleteAlert") 492 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 493 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 494 request.Method = "POST" 495 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 496 if err != nil { 497 return out, metadata, &smithy.SerializationError{Err: err} 498 } 499 500 restEncoder.SetHeader("Content-Type").String("application/json") 501 502 jsonEncoder := smithyjson.NewEncoder() 503 if err := awsRestjson1_serializeOpDocumentDeleteAlertInput(input, jsonEncoder.Value); err != nil { 504 return out, metadata, &smithy.SerializationError{Err: err} 505 } 506 507 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 508 return out, metadata, &smithy.SerializationError{Err: err} 509 } 510 511 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 512 return out, metadata, &smithy.SerializationError{Err: err} 513 } 514 in.Request = request 515 516 return next.HandleSerialize(ctx, in) 517} 518func awsRestjson1_serializeOpHttpBindingsDeleteAlertInput(v *DeleteAlertInput, encoder *httpbinding.Encoder) error { 519 if v == nil { 520 return fmt.Errorf("unsupported serialization of nil %T", v) 521 } 522 523 return nil 524} 525 526func awsRestjson1_serializeOpDocumentDeleteAlertInput(v *DeleteAlertInput, value smithyjson.Value) error { 527 object := value.Object() 528 defer object.Close() 529 530 if v.AlertArn != nil { 531 ok := object.Key("AlertArn") 532 ok.String(*v.AlertArn) 533 } 534 535 return nil 536} 537 538type awsRestjson1_serializeOpDeleteAnomalyDetector struct { 539} 540 541func (*awsRestjson1_serializeOpDeleteAnomalyDetector) ID() string { 542 return "OperationSerializer" 543} 544 545func (m *awsRestjson1_serializeOpDeleteAnomalyDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 546 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 547) { 548 request, ok := in.Request.(*smithyhttp.Request) 549 if !ok { 550 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 551 } 552 553 input, ok := in.Parameters.(*DeleteAnomalyDetectorInput) 554 _ = input 555 if !ok { 556 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 557 } 558 559 opPath, opQuery := httpbinding.SplitURI("/DeleteAnomalyDetector") 560 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 561 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 562 request.Method = "POST" 563 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 564 if err != nil { 565 return out, metadata, &smithy.SerializationError{Err: err} 566 } 567 568 restEncoder.SetHeader("Content-Type").String("application/json") 569 570 jsonEncoder := smithyjson.NewEncoder() 571 if err := awsRestjson1_serializeOpDocumentDeleteAnomalyDetectorInput(input, jsonEncoder.Value); err != nil { 572 return out, metadata, &smithy.SerializationError{Err: err} 573 } 574 575 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 576 return out, metadata, &smithy.SerializationError{Err: err} 577 } 578 579 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 580 return out, metadata, &smithy.SerializationError{Err: err} 581 } 582 in.Request = request 583 584 return next.HandleSerialize(ctx, in) 585} 586func awsRestjson1_serializeOpHttpBindingsDeleteAnomalyDetectorInput(v *DeleteAnomalyDetectorInput, encoder *httpbinding.Encoder) error { 587 if v == nil { 588 return fmt.Errorf("unsupported serialization of nil %T", v) 589 } 590 591 return nil 592} 593 594func awsRestjson1_serializeOpDocumentDeleteAnomalyDetectorInput(v *DeleteAnomalyDetectorInput, value smithyjson.Value) error { 595 object := value.Object() 596 defer object.Close() 597 598 if v.AnomalyDetectorArn != nil { 599 ok := object.Key("AnomalyDetectorArn") 600 ok.String(*v.AnomalyDetectorArn) 601 } 602 603 return nil 604} 605 606type awsRestjson1_serializeOpDescribeAlert struct { 607} 608 609func (*awsRestjson1_serializeOpDescribeAlert) ID() string { 610 return "OperationSerializer" 611} 612 613func (m *awsRestjson1_serializeOpDescribeAlert) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 614 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 615) { 616 request, ok := in.Request.(*smithyhttp.Request) 617 if !ok { 618 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 619 } 620 621 input, ok := in.Parameters.(*DescribeAlertInput) 622 _ = input 623 if !ok { 624 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 625 } 626 627 opPath, opQuery := httpbinding.SplitURI("/DescribeAlert") 628 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 629 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 630 request.Method = "POST" 631 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 632 if err != nil { 633 return out, metadata, &smithy.SerializationError{Err: err} 634 } 635 636 restEncoder.SetHeader("Content-Type").String("application/json") 637 638 jsonEncoder := smithyjson.NewEncoder() 639 if err := awsRestjson1_serializeOpDocumentDescribeAlertInput(input, jsonEncoder.Value); err != nil { 640 return out, metadata, &smithy.SerializationError{Err: err} 641 } 642 643 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 644 return out, metadata, &smithy.SerializationError{Err: err} 645 } 646 647 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 648 return out, metadata, &smithy.SerializationError{Err: err} 649 } 650 in.Request = request 651 652 return next.HandleSerialize(ctx, in) 653} 654func awsRestjson1_serializeOpHttpBindingsDescribeAlertInput(v *DescribeAlertInput, encoder *httpbinding.Encoder) error { 655 if v == nil { 656 return fmt.Errorf("unsupported serialization of nil %T", v) 657 } 658 659 return nil 660} 661 662func awsRestjson1_serializeOpDocumentDescribeAlertInput(v *DescribeAlertInput, value smithyjson.Value) error { 663 object := value.Object() 664 defer object.Close() 665 666 if v.AlertArn != nil { 667 ok := object.Key("AlertArn") 668 ok.String(*v.AlertArn) 669 } 670 671 return nil 672} 673 674type awsRestjson1_serializeOpDescribeAnomalyDetectionExecutions struct { 675} 676 677func (*awsRestjson1_serializeOpDescribeAnomalyDetectionExecutions) ID() string { 678 return "OperationSerializer" 679} 680 681func (m *awsRestjson1_serializeOpDescribeAnomalyDetectionExecutions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 682 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 683) { 684 request, ok := in.Request.(*smithyhttp.Request) 685 if !ok { 686 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 687 } 688 689 input, ok := in.Parameters.(*DescribeAnomalyDetectionExecutionsInput) 690 _ = input 691 if !ok { 692 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 693 } 694 695 opPath, opQuery := httpbinding.SplitURI("/DescribeAnomalyDetectionExecutions") 696 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 697 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 698 request.Method = "POST" 699 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 700 if err != nil { 701 return out, metadata, &smithy.SerializationError{Err: err} 702 } 703 704 restEncoder.SetHeader("Content-Type").String("application/json") 705 706 jsonEncoder := smithyjson.NewEncoder() 707 if err := awsRestjson1_serializeOpDocumentDescribeAnomalyDetectionExecutionsInput(input, jsonEncoder.Value); err != nil { 708 return out, metadata, &smithy.SerializationError{Err: err} 709 } 710 711 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 712 return out, metadata, &smithy.SerializationError{Err: err} 713 } 714 715 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 716 return out, metadata, &smithy.SerializationError{Err: err} 717 } 718 in.Request = request 719 720 return next.HandleSerialize(ctx, in) 721} 722func awsRestjson1_serializeOpHttpBindingsDescribeAnomalyDetectionExecutionsInput(v *DescribeAnomalyDetectionExecutionsInput, encoder *httpbinding.Encoder) error { 723 if v == nil { 724 return fmt.Errorf("unsupported serialization of nil %T", v) 725 } 726 727 return nil 728} 729 730func awsRestjson1_serializeOpDocumentDescribeAnomalyDetectionExecutionsInput(v *DescribeAnomalyDetectionExecutionsInput, value smithyjson.Value) error { 731 object := value.Object() 732 defer object.Close() 733 734 if v.AnomalyDetectorArn != nil { 735 ok := object.Key("AnomalyDetectorArn") 736 ok.String(*v.AnomalyDetectorArn) 737 } 738 739 if v.MaxResults != 0 { 740 ok := object.Key("MaxResults") 741 ok.Integer(v.MaxResults) 742 } 743 744 if v.NextToken != nil { 745 ok := object.Key("NextToken") 746 ok.String(*v.NextToken) 747 } 748 749 if v.Timestamp != nil { 750 ok := object.Key("Timestamp") 751 ok.String(*v.Timestamp) 752 } 753 754 return nil 755} 756 757type awsRestjson1_serializeOpDescribeAnomalyDetector struct { 758} 759 760func (*awsRestjson1_serializeOpDescribeAnomalyDetector) ID() string { 761 return "OperationSerializer" 762} 763 764func (m *awsRestjson1_serializeOpDescribeAnomalyDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 765 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 766) { 767 request, ok := in.Request.(*smithyhttp.Request) 768 if !ok { 769 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 770 } 771 772 input, ok := in.Parameters.(*DescribeAnomalyDetectorInput) 773 _ = input 774 if !ok { 775 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 776 } 777 778 opPath, opQuery := httpbinding.SplitURI("/DescribeAnomalyDetector") 779 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 780 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 781 request.Method = "POST" 782 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 783 if err != nil { 784 return out, metadata, &smithy.SerializationError{Err: err} 785 } 786 787 restEncoder.SetHeader("Content-Type").String("application/json") 788 789 jsonEncoder := smithyjson.NewEncoder() 790 if err := awsRestjson1_serializeOpDocumentDescribeAnomalyDetectorInput(input, jsonEncoder.Value); err != nil { 791 return out, metadata, &smithy.SerializationError{Err: err} 792 } 793 794 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 795 return out, metadata, &smithy.SerializationError{Err: err} 796 } 797 798 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 799 return out, metadata, &smithy.SerializationError{Err: err} 800 } 801 in.Request = request 802 803 return next.HandleSerialize(ctx, in) 804} 805func awsRestjson1_serializeOpHttpBindingsDescribeAnomalyDetectorInput(v *DescribeAnomalyDetectorInput, encoder *httpbinding.Encoder) error { 806 if v == nil { 807 return fmt.Errorf("unsupported serialization of nil %T", v) 808 } 809 810 return nil 811} 812 813func awsRestjson1_serializeOpDocumentDescribeAnomalyDetectorInput(v *DescribeAnomalyDetectorInput, value smithyjson.Value) error { 814 object := value.Object() 815 defer object.Close() 816 817 if v.AnomalyDetectorArn != nil { 818 ok := object.Key("AnomalyDetectorArn") 819 ok.String(*v.AnomalyDetectorArn) 820 } 821 822 return nil 823} 824 825type awsRestjson1_serializeOpDescribeMetricSet struct { 826} 827 828func (*awsRestjson1_serializeOpDescribeMetricSet) ID() string { 829 return "OperationSerializer" 830} 831 832func (m *awsRestjson1_serializeOpDescribeMetricSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 833 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 834) { 835 request, ok := in.Request.(*smithyhttp.Request) 836 if !ok { 837 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 838 } 839 840 input, ok := in.Parameters.(*DescribeMetricSetInput) 841 _ = input 842 if !ok { 843 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 844 } 845 846 opPath, opQuery := httpbinding.SplitURI("/DescribeMetricSet") 847 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 848 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 849 request.Method = "POST" 850 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 851 if err != nil { 852 return out, metadata, &smithy.SerializationError{Err: err} 853 } 854 855 restEncoder.SetHeader("Content-Type").String("application/json") 856 857 jsonEncoder := smithyjson.NewEncoder() 858 if err := awsRestjson1_serializeOpDocumentDescribeMetricSetInput(input, jsonEncoder.Value); err != nil { 859 return out, metadata, &smithy.SerializationError{Err: err} 860 } 861 862 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 863 return out, metadata, &smithy.SerializationError{Err: err} 864 } 865 866 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 867 return out, metadata, &smithy.SerializationError{Err: err} 868 } 869 in.Request = request 870 871 return next.HandleSerialize(ctx, in) 872} 873func awsRestjson1_serializeOpHttpBindingsDescribeMetricSetInput(v *DescribeMetricSetInput, encoder *httpbinding.Encoder) error { 874 if v == nil { 875 return fmt.Errorf("unsupported serialization of nil %T", v) 876 } 877 878 return nil 879} 880 881func awsRestjson1_serializeOpDocumentDescribeMetricSetInput(v *DescribeMetricSetInput, value smithyjson.Value) error { 882 object := value.Object() 883 defer object.Close() 884 885 if v.MetricSetArn != nil { 886 ok := object.Key("MetricSetArn") 887 ok.String(*v.MetricSetArn) 888 } 889 890 return nil 891} 892 893type awsRestjson1_serializeOpGetAnomalyGroup struct { 894} 895 896func (*awsRestjson1_serializeOpGetAnomalyGroup) ID() string { 897 return "OperationSerializer" 898} 899 900func (m *awsRestjson1_serializeOpGetAnomalyGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 901 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 902) { 903 request, ok := in.Request.(*smithyhttp.Request) 904 if !ok { 905 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 906 } 907 908 input, ok := in.Parameters.(*GetAnomalyGroupInput) 909 _ = input 910 if !ok { 911 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 912 } 913 914 opPath, opQuery := httpbinding.SplitURI("/GetAnomalyGroup") 915 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 916 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 917 request.Method = "POST" 918 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 919 if err != nil { 920 return out, metadata, &smithy.SerializationError{Err: err} 921 } 922 923 restEncoder.SetHeader("Content-Type").String("application/json") 924 925 jsonEncoder := smithyjson.NewEncoder() 926 if err := awsRestjson1_serializeOpDocumentGetAnomalyGroupInput(input, jsonEncoder.Value); err != nil { 927 return out, metadata, &smithy.SerializationError{Err: err} 928 } 929 930 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 931 return out, metadata, &smithy.SerializationError{Err: err} 932 } 933 934 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 935 return out, metadata, &smithy.SerializationError{Err: err} 936 } 937 in.Request = request 938 939 return next.HandleSerialize(ctx, in) 940} 941func awsRestjson1_serializeOpHttpBindingsGetAnomalyGroupInput(v *GetAnomalyGroupInput, encoder *httpbinding.Encoder) error { 942 if v == nil { 943 return fmt.Errorf("unsupported serialization of nil %T", v) 944 } 945 946 return nil 947} 948 949func awsRestjson1_serializeOpDocumentGetAnomalyGroupInput(v *GetAnomalyGroupInput, value smithyjson.Value) error { 950 object := value.Object() 951 defer object.Close() 952 953 if v.AnomalyDetectorArn != nil { 954 ok := object.Key("AnomalyDetectorArn") 955 ok.String(*v.AnomalyDetectorArn) 956 } 957 958 if v.AnomalyGroupId != nil { 959 ok := object.Key("AnomalyGroupId") 960 ok.String(*v.AnomalyGroupId) 961 } 962 963 return nil 964} 965 966type awsRestjson1_serializeOpGetFeedback struct { 967} 968 969func (*awsRestjson1_serializeOpGetFeedback) ID() string { 970 return "OperationSerializer" 971} 972 973func (m *awsRestjson1_serializeOpGetFeedback) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 974 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 975) { 976 request, ok := in.Request.(*smithyhttp.Request) 977 if !ok { 978 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 979 } 980 981 input, ok := in.Parameters.(*GetFeedbackInput) 982 _ = input 983 if !ok { 984 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 985 } 986 987 opPath, opQuery := httpbinding.SplitURI("/GetFeedback") 988 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 989 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 990 request.Method = "POST" 991 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 992 if err != nil { 993 return out, metadata, &smithy.SerializationError{Err: err} 994 } 995 996 restEncoder.SetHeader("Content-Type").String("application/json") 997 998 jsonEncoder := smithyjson.NewEncoder() 999 if err := awsRestjson1_serializeOpDocumentGetFeedbackInput(input, jsonEncoder.Value); err != nil { 1000 return out, metadata, &smithy.SerializationError{Err: err} 1001 } 1002 1003 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1004 return out, metadata, &smithy.SerializationError{Err: err} 1005 } 1006 1007 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1008 return out, metadata, &smithy.SerializationError{Err: err} 1009 } 1010 in.Request = request 1011 1012 return next.HandleSerialize(ctx, in) 1013} 1014func awsRestjson1_serializeOpHttpBindingsGetFeedbackInput(v *GetFeedbackInput, encoder *httpbinding.Encoder) error { 1015 if v == nil { 1016 return fmt.Errorf("unsupported serialization of nil %T", v) 1017 } 1018 1019 return nil 1020} 1021 1022func awsRestjson1_serializeOpDocumentGetFeedbackInput(v *GetFeedbackInput, value smithyjson.Value) error { 1023 object := value.Object() 1024 defer object.Close() 1025 1026 if v.AnomalyDetectorArn != nil { 1027 ok := object.Key("AnomalyDetectorArn") 1028 ok.String(*v.AnomalyDetectorArn) 1029 } 1030 1031 if v.AnomalyGroupTimeSeriesFeedback != nil { 1032 ok := object.Key("AnomalyGroupTimeSeriesFeedback") 1033 if err := awsRestjson1_serializeDocumentAnomalyGroupTimeSeries(v.AnomalyGroupTimeSeriesFeedback, ok); err != nil { 1034 return err 1035 } 1036 } 1037 1038 if v.MaxResults != 0 { 1039 ok := object.Key("MaxResults") 1040 ok.Integer(v.MaxResults) 1041 } 1042 1043 if v.NextToken != nil { 1044 ok := object.Key("NextToken") 1045 ok.String(*v.NextToken) 1046 } 1047 1048 return nil 1049} 1050 1051type awsRestjson1_serializeOpGetSampleData struct { 1052} 1053 1054func (*awsRestjson1_serializeOpGetSampleData) ID() string { 1055 return "OperationSerializer" 1056} 1057 1058func (m *awsRestjson1_serializeOpGetSampleData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1059 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1060) { 1061 request, ok := in.Request.(*smithyhttp.Request) 1062 if !ok { 1063 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1064 } 1065 1066 input, ok := in.Parameters.(*GetSampleDataInput) 1067 _ = input 1068 if !ok { 1069 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1070 } 1071 1072 opPath, opQuery := httpbinding.SplitURI("/GetSampleData") 1073 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1074 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1075 request.Method = "POST" 1076 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1077 if err != nil { 1078 return out, metadata, &smithy.SerializationError{Err: err} 1079 } 1080 1081 restEncoder.SetHeader("Content-Type").String("application/json") 1082 1083 jsonEncoder := smithyjson.NewEncoder() 1084 if err := awsRestjson1_serializeOpDocumentGetSampleDataInput(input, jsonEncoder.Value); err != nil { 1085 return out, metadata, &smithy.SerializationError{Err: err} 1086 } 1087 1088 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1089 return out, metadata, &smithy.SerializationError{Err: err} 1090 } 1091 1092 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1093 return out, metadata, &smithy.SerializationError{Err: err} 1094 } 1095 in.Request = request 1096 1097 return next.HandleSerialize(ctx, in) 1098} 1099func awsRestjson1_serializeOpHttpBindingsGetSampleDataInput(v *GetSampleDataInput, encoder *httpbinding.Encoder) error { 1100 if v == nil { 1101 return fmt.Errorf("unsupported serialization of nil %T", v) 1102 } 1103 1104 return nil 1105} 1106 1107func awsRestjson1_serializeOpDocumentGetSampleDataInput(v *GetSampleDataInput, value smithyjson.Value) error { 1108 object := value.Object() 1109 defer object.Close() 1110 1111 if v.S3SourceConfig != nil { 1112 ok := object.Key("S3SourceConfig") 1113 if err := awsRestjson1_serializeDocumentSampleDataS3SourceConfig(v.S3SourceConfig, ok); err != nil { 1114 return err 1115 } 1116 } 1117 1118 return nil 1119} 1120 1121type awsRestjson1_serializeOpListAlerts struct { 1122} 1123 1124func (*awsRestjson1_serializeOpListAlerts) ID() string { 1125 return "OperationSerializer" 1126} 1127 1128func (m *awsRestjson1_serializeOpListAlerts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1129 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1130) { 1131 request, ok := in.Request.(*smithyhttp.Request) 1132 if !ok { 1133 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1134 } 1135 1136 input, ok := in.Parameters.(*ListAlertsInput) 1137 _ = input 1138 if !ok { 1139 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1140 } 1141 1142 opPath, opQuery := httpbinding.SplitURI("/ListAlerts") 1143 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1144 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1145 request.Method = "POST" 1146 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1147 if err != nil { 1148 return out, metadata, &smithy.SerializationError{Err: err} 1149 } 1150 1151 restEncoder.SetHeader("Content-Type").String("application/json") 1152 1153 jsonEncoder := smithyjson.NewEncoder() 1154 if err := awsRestjson1_serializeOpDocumentListAlertsInput(input, jsonEncoder.Value); err != nil { 1155 return out, metadata, &smithy.SerializationError{Err: err} 1156 } 1157 1158 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1159 return out, metadata, &smithy.SerializationError{Err: err} 1160 } 1161 1162 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1163 return out, metadata, &smithy.SerializationError{Err: err} 1164 } 1165 in.Request = request 1166 1167 return next.HandleSerialize(ctx, in) 1168} 1169func awsRestjson1_serializeOpHttpBindingsListAlertsInput(v *ListAlertsInput, encoder *httpbinding.Encoder) error { 1170 if v == nil { 1171 return fmt.Errorf("unsupported serialization of nil %T", v) 1172 } 1173 1174 return nil 1175} 1176 1177func awsRestjson1_serializeOpDocumentListAlertsInput(v *ListAlertsInput, value smithyjson.Value) error { 1178 object := value.Object() 1179 defer object.Close() 1180 1181 if v.AnomalyDetectorArn != nil { 1182 ok := object.Key("AnomalyDetectorArn") 1183 ok.String(*v.AnomalyDetectorArn) 1184 } 1185 1186 if v.MaxResults != 0 { 1187 ok := object.Key("MaxResults") 1188 ok.Integer(v.MaxResults) 1189 } 1190 1191 if v.NextToken != nil { 1192 ok := object.Key("NextToken") 1193 ok.String(*v.NextToken) 1194 } 1195 1196 return nil 1197} 1198 1199type awsRestjson1_serializeOpListAnomalyDetectors struct { 1200} 1201 1202func (*awsRestjson1_serializeOpListAnomalyDetectors) ID() string { 1203 return "OperationSerializer" 1204} 1205 1206func (m *awsRestjson1_serializeOpListAnomalyDetectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1207 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1208) { 1209 request, ok := in.Request.(*smithyhttp.Request) 1210 if !ok { 1211 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1212 } 1213 1214 input, ok := in.Parameters.(*ListAnomalyDetectorsInput) 1215 _ = input 1216 if !ok { 1217 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1218 } 1219 1220 opPath, opQuery := httpbinding.SplitURI("/ListAnomalyDetectors") 1221 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1222 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1223 request.Method = "POST" 1224 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1225 if err != nil { 1226 return out, metadata, &smithy.SerializationError{Err: err} 1227 } 1228 1229 restEncoder.SetHeader("Content-Type").String("application/json") 1230 1231 jsonEncoder := smithyjson.NewEncoder() 1232 if err := awsRestjson1_serializeOpDocumentListAnomalyDetectorsInput(input, jsonEncoder.Value); err != nil { 1233 return out, metadata, &smithy.SerializationError{Err: err} 1234 } 1235 1236 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1237 return out, metadata, &smithy.SerializationError{Err: err} 1238 } 1239 1240 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1241 return out, metadata, &smithy.SerializationError{Err: err} 1242 } 1243 in.Request = request 1244 1245 return next.HandleSerialize(ctx, in) 1246} 1247func awsRestjson1_serializeOpHttpBindingsListAnomalyDetectorsInput(v *ListAnomalyDetectorsInput, encoder *httpbinding.Encoder) error { 1248 if v == nil { 1249 return fmt.Errorf("unsupported serialization of nil %T", v) 1250 } 1251 1252 return nil 1253} 1254 1255func awsRestjson1_serializeOpDocumentListAnomalyDetectorsInput(v *ListAnomalyDetectorsInput, value smithyjson.Value) error { 1256 object := value.Object() 1257 defer object.Close() 1258 1259 if v.MaxResults != 0 { 1260 ok := object.Key("MaxResults") 1261 ok.Integer(v.MaxResults) 1262 } 1263 1264 if v.NextToken != nil { 1265 ok := object.Key("NextToken") 1266 ok.String(*v.NextToken) 1267 } 1268 1269 return nil 1270} 1271 1272type awsRestjson1_serializeOpListAnomalyGroupSummaries struct { 1273} 1274 1275func (*awsRestjson1_serializeOpListAnomalyGroupSummaries) ID() string { 1276 return "OperationSerializer" 1277} 1278 1279func (m *awsRestjson1_serializeOpListAnomalyGroupSummaries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1280 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1281) { 1282 request, ok := in.Request.(*smithyhttp.Request) 1283 if !ok { 1284 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1285 } 1286 1287 input, ok := in.Parameters.(*ListAnomalyGroupSummariesInput) 1288 _ = input 1289 if !ok { 1290 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1291 } 1292 1293 opPath, opQuery := httpbinding.SplitURI("/ListAnomalyGroupSummaries") 1294 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1295 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1296 request.Method = "POST" 1297 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1298 if err != nil { 1299 return out, metadata, &smithy.SerializationError{Err: err} 1300 } 1301 1302 restEncoder.SetHeader("Content-Type").String("application/json") 1303 1304 jsonEncoder := smithyjson.NewEncoder() 1305 if err := awsRestjson1_serializeOpDocumentListAnomalyGroupSummariesInput(input, jsonEncoder.Value); err != nil { 1306 return out, metadata, &smithy.SerializationError{Err: err} 1307 } 1308 1309 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1310 return out, metadata, &smithy.SerializationError{Err: err} 1311 } 1312 1313 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1314 return out, metadata, &smithy.SerializationError{Err: err} 1315 } 1316 in.Request = request 1317 1318 return next.HandleSerialize(ctx, in) 1319} 1320func awsRestjson1_serializeOpHttpBindingsListAnomalyGroupSummariesInput(v *ListAnomalyGroupSummariesInput, encoder *httpbinding.Encoder) error { 1321 if v == nil { 1322 return fmt.Errorf("unsupported serialization of nil %T", v) 1323 } 1324 1325 return nil 1326} 1327 1328func awsRestjson1_serializeOpDocumentListAnomalyGroupSummariesInput(v *ListAnomalyGroupSummariesInput, value smithyjson.Value) error { 1329 object := value.Object() 1330 defer object.Close() 1331 1332 if v.AnomalyDetectorArn != nil { 1333 ok := object.Key("AnomalyDetectorArn") 1334 ok.String(*v.AnomalyDetectorArn) 1335 } 1336 1337 if v.MaxResults != 0 { 1338 ok := object.Key("MaxResults") 1339 ok.Integer(v.MaxResults) 1340 } 1341 1342 if v.NextToken != nil { 1343 ok := object.Key("NextToken") 1344 ok.String(*v.NextToken) 1345 } 1346 1347 { 1348 ok := object.Key("SensitivityThreshold") 1349 ok.Integer(v.SensitivityThreshold) 1350 } 1351 1352 return nil 1353} 1354 1355type awsRestjson1_serializeOpListAnomalyGroupTimeSeries struct { 1356} 1357 1358func (*awsRestjson1_serializeOpListAnomalyGroupTimeSeries) ID() string { 1359 return "OperationSerializer" 1360} 1361 1362func (m *awsRestjson1_serializeOpListAnomalyGroupTimeSeries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1363 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1364) { 1365 request, ok := in.Request.(*smithyhttp.Request) 1366 if !ok { 1367 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1368 } 1369 1370 input, ok := in.Parameters.(*ListAnomalyGroupTimeSeriesInput) 1371 _ = input 1372 if !ok { 1373 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1374 } 1375 1376 opPath, opQuery := httpbinding.SplitURI("/ListAnomalyGroupTimeSeries") 1377 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1378 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1379 request.Method = "POST" 1380 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1381 if err != nil { 1382 return out, metadata, &smithy.SerializationError{Err: err} 1383 } 1384 1385 restEncoder.SetHeader("Content-Type").String("application/json") 1386 1387 jsonEncoder := smithyjson.NewEncoder() 1388 if err := awsRestjson1_serializeOpDocumentListAnomalyGroupTimeSeriesInput(input, jsonEncoder.Value); err != nil { 1389 return out, metadata, &smithy.SerializationError{Err: err} 1390 } 1391 1392 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1393 return out, metadata, &smithy.SerializationError{Err: err} 1394 } 1395 1396 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1397 return out, metadata, &smithy.SerializationError{Err: err} 1398 } 1399 in.Request = request 1400 1401 return next.HandleSerialize(ctx, in) 1402} 1403func awsRestjson1_serializeOpHttpBindingsListAnomalyGroupTimeSeriesInput(v *ListAnomalyGroupTimeSeriesInput, encoder *httpbinding.Encoder) error { 1404 if v == nil { 1405 return fmt.Errorf("unsupported serialization of nil %T", v) 1406 } 1407 1408 return nil 1409} 1410 1411func awsRestjson1_serializeOpDocumentListAnomalyGroupTimeSeriesInput(v *ListAnomalyGroupTimeSeriesInput, value smithyjson.Value) error { 1412 object := value.Object() 1413 defer object.Close() 1414 1415 if v.AnomalyDetectorArn != nil { 1416 ok := object.Key("AnomalyDetectorArn") 1417 ok.String(*v.AnomalyDetectorArn) 1418 } 1419 1420 if v.AnomalyGroupId != nil { 1421 ok := object.Key("AnomalyGroupId") 1422 ok.String(*v.AnomalyGroupId) 1423 } 1424 1425 if v.MaxResults != 0 { 1426 ok := object.Key("MaxResults") 1427 ok.Integer(v.MaxResults) 1428 } 1429 1430 if v.MetricName != nil { 1431 ok := object.Key("MetricName") 1432 ok.String(*v.MetricName) 1433 } 1434 1435 if v.NextToken != nil { 1436 ok := object.Key("NextToken") 1437 ok.String(*v.NextToken) 1438 } 1439 1440 return nil 1441} 1442 1443type awsRestjson1_serializeOpListMetricSets struct { 1444} 1445 1446func (*awsRestjson1_serializeOpListMetricSets) ID() string { 1447 return "OperationSerializer" 1448} 1449 1450func (m *awsRestjson1_serializeOpListMetricSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1451 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1452) { 1453 request, ok := in.Request.(*smithyhttp.Request) 1454 if !ok { 1455 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1456 } 1457 1458 input, ok := in.Parameters.(*ListMetricSetsInput) 1459 _ = input 1460 if !ok { 1461 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1462 } 1463 1464 opPath, opQuery := httpbinding.SplitURI("/ListMetricSets") 1465 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1466 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1467 request.Method = "POST" 1468 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1469 if err != nil { 1470 return out, metadata, &smithy.SerializationError{Err: err} 1471 } 1472 1473 restEncoder.SetHeader("Content-Type").String("application/json") 1474 1475 jsonEncoder := smithyjson.NewEncoder() 1476 if err := awsRestjson1_serializeOpDocumentListMetricSetsInput(input, jsonEncoder.Value); err != nil { 1477 return out, metadata, &smithy.SerializationError{Err: err} 1478 } 1479 1480 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1481 return out, metadata, &smithy.SerializationError{Err: err} 1482 } 1483 1484 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1485 return out, metadata, &smithy.SerializationError{Err: err} 1486 } 1487 in.Request = request 1488 1489 return next.HandleSerialize(ctx, in) 1490} 1491func awsRestjson1_serializeOpHttpBindingsListMetricSetsInput(v *ListMetricSetsInput, encoder *httpbinding.Encoder) error { 1492 if v == nil { 1493 return fmt.Errorf("unsupported serialization of nil %T", v) 1494 } 1495 1496 return nil 1497} 1498 1499func awsRestjson1_serializeOpDocumentListMetricSetsInput(v *ListMetricSetsInput, value smithyjson.Value) error { 1500 object := value.Object() 1501 defer object.Close() 1502 1503 if v.AnomalyDetectorArn != nil { 1504 ok := object.Key("AnomalyDetectorArn") 1505 ok.String(*v.AnomalyDetectorArn) 1506 } 1507 1508 if v.MaxResults != 0 { 1509 ok := object.Key("MaxResults") 1510 ok.Integer(v.MaxResults) 1511 } 1512 1513 if v.NextToken != nil { 1514 ok := object.Key("NextToken") 1515 ok.String(*v.NextToken) 1516 } 1517 1518 return nil 1519} 1520 1521type awsRestjson1_serializeOpListTagsForResource struct { 1522} 1523 1524func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 1525 return "OperationSerializer" 1526} 1527 1528func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1529 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1530) { 1531 request, ok := in.Request.(*smithyhttp.Request) 1532 if !ok { 1533 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1534 } 1535 1536 input, ok := in.Parameters.(*ListTagsForResourceInput) 1537 _ = input 1538 if !ok { 1539 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1540 } 1541 1542 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1543 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1544 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1545 request.Method = "GET" 1546 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1547 if err != nil { 1548 return out, metadata, &smithy.SerializationError{Err: err} 1549 } 1550 1551 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 1552 return out, metadata, &smithy.SerializationError{Err: err} 1553 } 1554 1555 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1556 return out, metadata, &smithy.SerializationError{Err: err} 1557 } 1558 in.Request = request 1559 1560 return next.HandleSerialize(ctx, in) 1561} 1562func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1563 if v == nil { 1564 return fmt.Errorf("unsupported serialization of nil %T", v) 1565 } 1566 1567 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1568 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1569 } 1570 if v.ResourceArn != nil { 1571 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1572 return err 1573 } 1574 } 1575 1576 return nil 1577} 1578 1579type awsRestjson1_serializeOpPutFeedback struct { 1580} 1581 1582func (*awsRestjson1_serializeOpPutFeedback) ID() string { 1583 return "OperationSerializer" 1584} 1585 1586func (m *awsRestjson1_serializeOpPutFeedback) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1587 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1588) { 1589 request, ok := in.Request.(*smithyhttp.Request) 1590 if !ok { 1591 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1592 } 1593 1594 input, ok := in.Parameters.(*PutFeedbackInput) 1595 _ = input 1596 if !ok { 1597 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1598 } 1599 1600 opPath, opQuery := httpbinding.SplitURI("/PutFeedback") 1601 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1602 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1603 request.Method = "POST" 1604 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1605 if err != nil { 1606 return out, metadata, &smithy.SerializationError{Err: err} 1607 } 1608 1609 restEncoder.SetHeader("Content-Type").String("application/json") 1610 1611 jsonEncoder := smithyjson.NewEncoder() 1612 if err := awsRestjson1_serializeOpDocumentPutFeedbackInput(input, jsonEncoder.Value); err != nil { 1613 return out, metadata, &smithy.SerializationError{Err: err} 1614 } 1615 1616 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1617 return out, metadata, &smithy.SerializationError{Err: err} 1618 } 1619 1620 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1621 return out, metadata, &smithy.SerializationError{Err: err} 1622 } 1623 in.Request = request 1624 1625 return next.HandleSerialize(ctx, in) 1626} 1627func awsRestjson1_serializeOpHttpBindingsPutFeedbackInput(v *PutFeedbackInput, encoder *httpbinding.Encoder) error { 1628 if v == nil { 1629 return fmt.Errorf("unsupported serialization of nil %T", v) 1630 } 1631 1632 return nil 1633} 1634 1635func awsRestjson1_serializeOpDocumentPutFeedbackInput(v *PutFeedbackInput, value smithyjson.Value) error { 1636 object := value.Object() 1637 defer object.Close() 1638 1639 if v.AnomalyDetectorArn != nil { 1640 ok := object.Key("AnomalyDetectorArn") 1641 ok.String(*v.AnomalyDetectorArn) 1642 } 1643 1644 if v.AnomalyGroupTimeSeriesFeedback != nil { 1645 ok := object.Key("AnomalyGroupTimeSeriesFeedback") 1646 if err := awsRestjson1_serializeDocumentAnomalyGroupTimeSeriesFeedback(v.AnomalyGroupTimeSeriesFeedback, ok); err != nil { 1647 return err 1648 } 1649 } 1650 1651 return nil 1652} 1653 1654type awsRestjson1_serializeOpTagResource struct { 1655} 1656 1657func (*awsRestjson1_serializeOpTagResource) ID() string { 1658 return "OperationSerializer" 1659} 1660 1661func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1662 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1663) { 1664 request, ok := in.Request.(*smithyhttp.Request) 1665 if !ok { 1666 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1667 } 1668 1669 input, ok := in.Parameters.(*TagResourceInput) 1670 _ = input 1671 if !ok { 1672 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1673 } 1674 1675 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1676 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1677 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1678 request.Method = "POST" 1679 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1680 if err != nil { 1681 return out, metadata, &smithy.SerializationError{Err: err} 1682 } 1683 1684 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 1685 return out, metadata, &smithy.SerializationError{Err: err} 1686 } 1687 1688 restEncoder.SetHeader("Content-Type").String("application/json") 1689 1690 jsonEncoder := smithyjson.NewEncoder() 1691 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 1692 return out, metadata, &smithy.SerializationError{Err: err} 1693 } 1694 1695 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1696 return out, metadata, &smithy.SerializationError{Err: err} 1697 } 1698 1699 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1700 return out, metadata, &smithy.SerializationError{Err: err} 1701 } 1702 in.Request = request 1703 1704 return next.HandleSerialize(ctx, in) 1705} 1706func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 1707 if v == nil { 1708 return fmt.Errorf("unsupported serialization of nil %T", v) 1709 } 1710 1711 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1712 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1713 } 1714 if v.ResourceArn != nil { 1715 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1716 return err 1717 } 1718 } 1719 1720 return nil 1721} 1722 1723func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 1724 object := value.Object() 1725 defer object.Close() 1726 1727 if v.Tags != nil { 1728 ok := object.Key("tags") 1729 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1730 return err 1731 } 1732 } 1733 1734 return nil 1735} 1736 1737type awsRestjson1_serializeOpUntagResource struct { 1738} 1739 1740func (*awsRestjson1_serializeOpUntagResource) ID() string { 1741 return "OperationSerializer" 1742} 1743 1744func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1745 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1746) { 1747 request, ok := in.Request.(*smithyhttp.Request) 1748 if !ok { 1749 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1750 } 1751 1752 input, ok := in.Parameters.(*UntagResourceInput) 1753 _ = input 1754 if !ok { 1755 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1756 } 1757 1758 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1759 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1760 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1761 request.Method = "DELETE" 1762 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1763 if err != nil { 1764 return out, metadata, &smithy.SerializationError{Err: err} 1765 } 1766 1767 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 1768 return out, metadata, &smithy.SerializationError{Err: err} 1769 } 1770 1771 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1772 return out, metadata, &smithy.SerializationError{Err: err} 1773 } 1774 in.Request = request 1775 1776 return next.HandleSerialize(ctx, in) 1777} 1778func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 1779 if v == nil { 1780 return fmt.Errorf("unsupported serialization of nil %T", v) 1781 } 1782 1783 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1784 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1785 } 1786 if v.ResourceArn != nil { 1787 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1788 return err 1789 } 1790 } 1791 1792 if v.TagKeys != nil { 1793 for i := range v.TagKeys { 1794 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 1795 } 1796 } 1797 1798 return nil 1799} 1800 1801type awsRestjson1_serializeOpUpdateAnomalyDetector struct { 1802} 1803 1804func (*awsRestjson1_serializeOpUpdateAnomalyDetector) ID() string { 1805 return "OperationSerializer" 1806} 1807 1808func (m *awsRestjson1_serializeOpUpdateAnomalyDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1809 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1810) { 1811 request, ok := in.Request.(*smithyhttp.Request) 1812 if !ok { 1813 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1814 } 1815 1816 input, ok := in.Parameters.(*UpdateAnomalyDetectorInput) 1817 _ = input 1818 if !ok { 1819 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1820 } 1821 1822 opPath, opQuery := httpbinding.SplitURI("/UpdateAnomalyDetector") 1823 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1824 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1825 request.Method = "POST" 1826 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1827 if err != nil { 1828 return out, metadata, &smithy.SerializationError{Err: err} 1829 } 1830 1831 restEncoder.SetHeader("Content-Type").String("application/json") 1832 1833 jsonEncoder := smithyjson.NewEncoder() 1834 if err := awsRestjson1_serializeOpDocumentUpdateAnomalyDetectorInput(input, jsonEncoder.Value); err != nil { 1835 return out, metadata, &smithy.SerializationError{Err: err} 1836 } 1837 1838 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1839 return out, metadata, &smithy.SerializationError{Err: err} 1840 } 1841 1842 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1843 return out, metadata, &smithy.SerializationError{Err: err} 1844 } 1845 in.Request = request 1846 1847 return next.HandleSerialize(ctx, in) 1848} 1849func awsRestjson1_serializeOpHttpBindingsUpdateAnomalyDetectorInput(v *UpdateAnomalyDetectorInput, encoder *httpbinding.Encoder) error { 1850 if v == nil { 1851 return fmt.Errorf("unsupported serialization of nil %T", v) 1852 } 1853 1854 return nil 1855} 1856 1857func awsRestjson1_serializeOpDocumentUpdateAnomalyDetectorInput(v *UpdateAnomalyDetectorInput, value smithyjson.Value) error { 1858 object := value.Object() 1859 defer object.Close() 1860 1861 if v.AnomalyDetectorArn != nil { 1862 ok := object.Key("AnomalyDetectorArn") 1863 ok.String(*v.AnomalyDetectorArn) 1864 } 1865 1866 if v.AnomalyDetectorConfig != nil { 1867 ok := object.Key("AnomalyDetectorConfig") 1868 if err := awsRestjson1_serializeDocumentAnomalyDetectorConfig(v.AnomalyDetectorConfig, ok); err != nil { 1869 return err 1870 } 1871 } 1872 1873 if v.AnomalyDetectorDescription != nil { 1874 ok := object.Key("AnomalyDetectorDescription") 1875 ok.String(*v.AnomalyDetectorDescription) 1876 } 1877 1878 if v.KmsKeyArn != nil { 1879 ok := object.Key("KmsKeyArn") 1880 ok.String(*v.KmsKeyArn) 1881 } 1882 1883 return nil 1884} 1885 1886type awsRestjson1_serializeOpUpdateMetricSet struct { 1887} 1888 1889func (*awsRestjson1_serializeOpUpdateMetricSet) ID() string { 1890 return "OperationSerializer" 1891} 1892 1893func (m *awsRestjson1_serializeOpUpdateMetricSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1894 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1895) { 1896 request, ok := in.Request.(*smithyhttp.Request) 1897 if !ok { 1898 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1899 } 1900 1901 input, ok := in.Parameters.(*UpdateMetricSetInput) 1902 _ = input 1903 if !ok { 1904 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1905 } 1906 1907 opPath, opQuery := httpbinding.SplitURI("/UpdateMetricSet") 1908 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1909 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1910 request.Method = "POST" 1911 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1912 if err != nil { 1913 return out, metadata, &smithy.SerializationError{Err: err} 1914 } 1915 1916 restEncoder.SetHeader("Content-Type").String("application/json") 1917 1918 jsonEncoder := smithyjson.NewEncoder() 1919 if err := awsRestjson1_serializeOpDocumentUpdateMetricSetInput(input, jsonEncoder.Value); err != nil { 1920 return out, metadata, &smithy.SerializationError{Err: err} 1921 } 1922 1923 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1924 return out, metadata, &smithy.SerializationError{Err: err} 1925 } 1926 1927 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1928 return out, metadata, &smithy.SerializationError{Err: err} 1929 } 1930 in.Request = request 1931 1932 return next.HandleSerialize(ctx, in) 1933} 1934func awsRestjson1_serializeOpHttpBindingsUpdateMetricSetInput(v *UpdateMetricSetInput, encoder *httpbinding.Encoder) error { 1935 if v == nil { 1936 return fmt.Errorf("unsupported serialization of nil %T", v) 1937 } 1938 1939 return nil 1940} 1941 1942func awsRestjson1_serializeOpDocumentUpdateMetricSetInput(v *UpdateMetricSetInput, value smithyjson.Value) error { 1943 object := value.Object() 1944 defer object.Close() 1945 1946 if v.DimensionList != nil { 1947 ok := object.Key("DimensionList") 1948 if err := awsRestjson1_serializeDocumentDimensionList(v.DimensionList, ok); err != nil { 1949 return err 1950 } 1951 } 1952 1953 if v.MetricList != nil { 1954 ok := object.Key("MetricList") 1955 if err := awsRestjson1_serializeDocumentMetricList(v.MetricList, ok); err != nil { 1956 return err 1957 } 1958 } 1959 1960 if v.MetricSetArn != nil { 1961 ok := object.Key("MetricSetArn") 1962 ok.String(*v.MetricSetArn) 1963 } 1964 1965 if v.MetricSetDescription != nil { 1966 ok := object.Key("MetricSetDescription") 1967 ok.String(*v.MetricSetDescription) 1968 } 1969 1970 if len(v.MetricSetFrequency) > 0 { 1971 ok := object.Key("MetricSetFrequency") 1972 ok.String(string(v.MetricSetFrequency)) 1973 } 1974 1975 if v.MetricSource != nil { 1976 ok := object.Key("MetricSource") 1977 if err := awsRestjson1_serializeDocumentMetricSource(v.MetricSource, ok); err != nil { 1978 return err 1979 } 1980 } 1981 1982 if v.Offset != 0 { 1983 ok := object.Key("Offset") 1984 ok.Integer(v.Offset) 1985 } 1986 1987 if v.TimestampColumn != nil { 1988 ok := object.Key("TimestampColumn") 1989 if err := awsRestjson1_serializeDocumentTimestampColumn(v.TimestampColumn, ok); err != nil { 1990 return err 1991 } 1992 } 1993 1994 return nil 1995} 1996 1997func awsRestjson1_serializeDocumentAction(v *types.Action, value smithyjson.Value) error { 1998 object := value.Object() 1999 defer object.Close() 2000 2001 if v.LambdaConfiguration != nil { 2002 ok := object.Key("LambdaConfiguration") 2003 if err := awsRestjson1_serializeDocumentLambdaConfiguration(v.LambdaConfiguration, ok); err != nil { 2004 return err 2005 } 2006 } 2007 2008 if v.SNSConfiguration != nil { 2009 ok := object.Key("SNSConfiguration") 2010 if err := awsRestjson1_serializeDocumentSNSConfiguration(v.SNSConfiguration, ok); err != nil { 2011 return err 2012 } 2013 } 2014 2015 return nil 2016} 2017 2018func awsRestjson1_serializeDocumentAnomalyDetectorConfig(v *types.AnomalyDetectorConfig, value smithyjson.Value) error { 2019 object := value.Object() 2020 defer object.Close() 2021 2022 if len(v.AnomalyDetectorFrequency) > 0 { 2023 ok := object.Key("AnomalyDetectorFrequency") 2024 ok.String(string(v.AnomalyDetectorFrequency)) 2025 } 2026 2027 return nil 2028} 2029 2030func awsRestjson1_serializeDocumentAnomalyGroupTimeSeries(v *types.AnomalyGroupTimeSeries, value smithyjson.Value) error { 2031 object := value.Object() 2032 defer object.Close() 2033 2034 if v.AnomalyGroupId != nil { 2035 ok := object.Key("AnomalyGroupId") 2036 ok.String(*v.AnomalyGroupId) 2037 } 2038 2039 if v.TimeSeriesId != nil { 2040 ok := object.Key("TimeSeriesId") 2041 ok.String(*v.TimeSeriesId) 2042 } 2043 2044 return nil 2045} 2046 2047func awsRestjson1_serializeDocumentAnomalyGroupTimeSeriesFeedback(v *types.AnomalyGroupTimeSeriesFeedback, value smithyjson.Value) error { 2048 object := value.Object() 2049 defer object.Close() 2050 2051 if v.AnomalyGroupId != nil { 2052 ok := object.Key("AnomalyGroupId") 2053 ok.String(*v.AnomalyGroupId) 2054 } 2055 2056 if v.IsAnomaly != nil { 2057 ok := object.Key("IsAnomaly") 2058 ok.Boolean(*v.IsAnomaly) 2059 } 2060 2061 if v.TimeSeriesId != nil { 2062 ok := object.Key("TimeSeriesId") 2063 ok.String(*v.TimeSeriesId) 2064 } 2065 2066 return nil 2067} 2068 2069func awsRestjson1_serializeDocumentAppFlowConfig(v *types.AppFlowConfig, value smithyjson.Value) error { 2070 object := value.Object() 2071 defer object.Close() 2072 2073 if v.FlowName != nil { 2074 ok := object.Key("FlowName") 2075 ok.String(*v.FlowName) 2076 } 2077 2078 if v.RoleArn != nil { 2079 ok := object.Key("RoleArn") 2080 ok.String(*v.RoleArn) 2081 } 2082 2083 return nil 2084} 2085 2086func awsRestjson1_serializeDocumentCloudWatchConfig(v *types.CloudWatchConfig, value smithyjson.Value) error { 2087 object := value.Object() 2088 defer object.Close() 2089 2090 if v.RoleArn != nil { 2091 ok := object.Key("RoleArn") 2092 ok.String(*v.RoleArn) 2093 } 2094 2095 return nil 2096} 2097 2098func awsRestjson1_serializeDocumentCsvFormatDescriptor(v *types.CsvFormatDescriptor, value smithyjson.Value) error { 2099 object := value.Object() 2100 defer object.Close() 2101 2102 if v.Charset != nil { 2103 ok := object.Key("Charset") 2104 ok.String(*v.Charset) 2105 } 2106 2107 if v.ContainsHeader != nil { 2108 ok := object.Key("ContainsHeader") 2109 ok.Boolean(*v.ContainsHeader) 2110 } 2111 2112 if v.Delimiter != nil { 2113 ok := object.Key("Delimiter") 2114 ok.String(*v.Delimiter) 2115 } 2116 2117 if len(v.FileCompression) > 0 { 2118 ok := object.Key("FileCompression") 2119 ok.String(string(v.FileCompression)) 2120 } 2121 2122 if v.HeaderList != nil { 2123 ok := object.Key("HeaderList") 2124 if err := awsRestjson1_serializeDocumentHeaderList(v.HeaderList, ok); err != nil { 2125 return err 2126 } 2127 } 2128 2129 if v.QuoteSymbol != nil { 2130 ok := object.Key("QuoteSymbol") 2131 ok.String(*v.QuoteSymbol) 2132 } 2133 2134 return nil 2135} 2136 2137func awsRestjson1_serializeDocumentDimensionList(v []string, value smithyjson.Value) error { 2138 array := value.Array() 2139 defer array.Close() 2140 2141 for i := range v { 2142 av := array.Value() 2143 av.String(v[i]) 2144 } 2145 return nil 2146} 2147 2148func awsRestjson1_serializeDocumentFileFormatDescriptor(v *types.FileFormatDescriptor, value smithyjson.Value) error { 2149 object := value.Object() 2150 defer object.Close() 2151 2152 if v.CsvFormatDescriptor != nil { 2153 ok := object.Key("CsvFormatDescriptor") 2154 if err := awsRestjson1_serializeDocumentCsvFormatDescriptor(v.CsvFormatDescriptor, ok); err != nil { 2155 return err 2156 } 2157 } 2158 2159 if v.JsonFormatDescriptor != nil { 2160 ok := object.Key("JsonFormatDescriptor") 2161 if err := awsRestjson1_serializeDocumentJsonFormatDescriptor(v.JsonFormatDescriptor, ok); err != nil { 2162 return err 2163 } 2164 } 2165 2166 return nil 2167} 2168 2169func awsRestjson1_serializeDocumentHeaderList(v []string, value smithyjson.Value) error { 2170 array := value.Array() 2171 defer array.Close() 2172 2173 for i := range v { 2174 av := array.Value() 2175 av.String(v[i]) 2176 } 2177 return nil 2178} 2179 2180func awsRestjson1_serializeDocumentHistoricalDataPathList(v []string, value smithyjson.Value) error { 2181 array := value.Array() 2182 defer array.Close() 2183 2184 for i := range v { 2185 av := array.Value() 2186 av.String(v[i]) 2187 } 2188 return nil 2189} 2190 2191func awsRestjson1_serializeDocumentJsonFormatDescriptor(v *types.JsonFormatDescriptor, value smithyjson.Value) error { 2192 object := value.Object() 2193 defer object.Close() 2194 2195 if v.Charset != nil { 2196 ok := object.Key("Charset") 2197 ok.String(*v.Charset) 2198 } 2199 2200 if len(v.FileCompression) > 0 { 2201 ok := object.Key("FileCompression") 2202 ok.String(string(v.FileCompression)) 2203 } 2204 2205 return nil 2206} 2207 2208func awsRestjson1_serializeDocumentLambdaConfiguration(v *types.LambdaConfiguration, value smithyjson.Value) error { 2209 object := value.Object() 2210 defer object.Close() 2211 2212 if v.LambdaArn != nil { 2213 ok := object.Key("LambdaArn") 2214 ok.String(*v.LambdaArn) 2215 } 2216 2217 if v.RoleArn != nil { 2218 ok := object.Key("RoleArn") 2219 ok.String(*v.RoleArn) 2220 } 2221 2222 return nil 2223} 2224 2225func awsRestjson1_serializeDocumentMetric(v *types.Metric, value smithyjson.Value) error { 2226 object := value.Object() 2227 defer object.Close() 2228 2229 if len(v.AggregationFunction) > 0 { 2230 ok := object.Key("AggregationFunction") 2231 ok.String(string(v.AggregationFunction)) 2232 } 2233 2234 if v.MetricName != nil { 2235 ok := object.Key("MetricName") 2236 ok.String(*v.MetricName) 2237 } 2238 2239 if v.Namespace != nil { 2240 ok := object.Key("Namespace") 2241 ok.String(*v.Namespace) 2242 } 2243 2244 return nil 2245} 2246 2247func awsRestjson1_serializeDocumentMetricList(v []types.Metric, value smithyjson.Value) error { 2248 array := value.Array() 2249 defer array.Close() 2250 2251 for i := range v { 2252 av := array.Value() 2253 if err := awsRestjson1_serializeDocumentMetric(&v[i], av); err != nil { 2254 return err 2255 } 2256 } 2257 return nil 2258} 2259 2260func awsRestjson1_serializeDocumentMetricSource(v *types.MetricSource, value smithyjson.Value) error { 2261 object := value.Object() 2262 defer object.Close() 2263 2264 if v.AppFlowConfig != nil { 2265 ok := object.Key("AppFlowConfig") 2266 if err := awsRestjson1_serializeDocumentAppFlowConfig(v.AppFlowConfig, ok); err != nil { 2267 return err 2268 } 2269 } 2270 2271 if v.CloudWatchConfig != nil { 2272 ok := object.Key("CloudWatchConfig") 2273 if err := awsRestjson1_serializeDocumentCloudWatchConfig(v.CloudWatchConfig, ok); err != nil { 2274 return err 2275 } 2276 } 2277 2278 if v.RDSSourceConfig != nil { 2279 ok := object.Key("RDSSourceConfig") 2280 if err := awsRestjson1_serializeDocumentRDSSourceConfig(v.RDSSourceConfig, ok); err != nil { 2281 return err 2282 } 2283 } 2284 2285 if v.RedshiftSourceConfig != nil { 2286 ok := object.Key("RedshiftSourceConfig") 2287 if err := awsRestjson1_serializeDocumentRedshiftSourceConfig(v.RedshiftSourceConfig, ok); err != nil { 2288 return err 2289 } 2290 } 2291 2292 if v.S3SourceConfig != nil { 2293 ok := object.Key("S3SourceConfig") 2294 if err := awsRestjson1_serializeDocumentS3SourceConfig(v.S3SourceConfig, ok); err != nil { 2295 return err 2296 } 2297 } 2298 2299 return nil 2300} 2301 2302func awsRestjson1_serializeDocumentRDSSourceConfig(v *types.RDSSourceConfig, value smithyjson.Value) error { 2303 object := value.Object() 2304 defer object.Close() 2305 2306 if v.DatabaseHost != nil { 2307 ok := object.Key("DatabaseHost") 2308 ok.String(*v.DatabaseHost) 2309 } 2310 2311 if v.DatabaseName != nil { 2312 ok := object.Key("DatabaseName") 2313 ok.String(*v.DatabaseName) 2314 } 2315 2316 { 2317 ok := object.Key("DatabasePort") 2318 ok.Integer(v.DatabasePort) 2319 } 2320 2321 if v.DBInstanceIdentifier != nil { 2322 ok := object.Key("DBInstanceIdentifier") 2323 ok.String(*v.DBInstanceIdentifier) 2324 } 2325 2326 if v.RoleArn != nil { 2327 ok := object.Key("RoleArn") 2328 ok.String(*v.RoleArn) 2329 } 2330 2331 if v.SecretManagerArn != nil { 2332 ok := object.Key("SecretManagerArn") 2333 ok.String(*v.SecretManagerArn) 2334 } 2335 2336 if v.TableName != nil { 2337 ok := object.Key("TableName") 2338 ok.String(*v.TableName) 2339 } 2340 2341 if v.VpcConfiguration != nil { 2342 ok := object.Key("VpcConfiguration") 2343 if err := awsRestjson1_serializeDocumentVpcConfiguration(v.VpcConfiguration, ok); err != nil { 2344 return err 2345 } 2346 } 2347 2348 return nil 2349} 2350 2351func awsRestjson1_serializeDocumentRedshiftSourceConfig(v *types.RedshiftSourceConfig, value smithyjson.Value) error { 2352 object := value.Object() 2353 defer object.Close() 2354 2355 if v.ClusterIdentifier != nil { 2356 ok := object.Key("ClusterIdentifier") 2357 ok.String(*v.ClusterIdentifier) 2358 } 2359 2360 if v.DatabaseHost != nil { 2361 ok := object.Key("DatabaseHost") 2362 ok.String(*v.DatabaseHost) 2363 } 2364 2365 if v.DatabaseName != nil { 2366 ok := object.Key("DatabaseName") 2367 ok.String(*v.DatabaseName) 2368 } 2369 2370 { 2371 ok := object.Key("DatabasePort") 2372 ok.Integer(v.DatabasePort) 2373 } 2374 2375 if v.RoleArn != nil { 2376 ok := object.Key("RoleArn") 2377 ok.String(*v.RoleArn) 2378 } 2379 2380 if v.SecretManagerArn != nil { 2381 ok := object.Key("SecretManagerArn") 2382 ok.String(*v.SecretManagerArn) 2383 } 2384 2385 if v.TableName != nil { 2386 ok := object.Key("TableName") 2387 ok.String(*v.TableName) 2388 } 2389 2390 if v.VpcConfiguration != nil { 2391 ok := object.Key("VpcConfiguration") 2392 if err := awsRestjson1_serializeDocumentVpcConfiguration(v.VpcConfiguration, ok); err != nil { 2393 return err 2394 } 2395 } 2396 2397 return nil 2398} 2399 2400func awsRestjson1_serializeDocumentS3SourceConfig(v *types.S3SourceConfig, value smithyjson.Value) error { 2401 object := value.Object() 2402 defer object.Close() 2403 2404 if v.FileFormatDescriptor != nil { 2405 ok := object.Key("FileFormatDescriptor") 2406 if err := awsRestjson1_serializeDocumentFileFormatDescriptor(v.FileFormatDescriptor, ok); err != nil { 2407 return err 2408 } 2409 } 2410 2411 if v.HistoricalDataPathList != nil { 2412 ok := object.Key("HistoricalDataPathList") 2413 if err := awsRestjson1_serializeDocumentHistoricalDataPathList(v.HistoricalDataPathList, ok); err != nil { 2414 return err 2415 } 2416 } 2417 2418 if v.RoleArn != nil { 2419 ok := object.Key("RoleArn") 2420 ok.String(*v.RoleArn) 2421 } 2422 2423 if v.TemplatedPathList != nil { 2424 ok := object.Key("TemplatedPathList") 2425 if err := awsRestjson1_serializeDocumentTemplatedPathList(v.TemplatedPathList, ok); err != nil { 2426 return err 2427 } 2428 } 2429 2430 return nil 2431} 2432 2433func awsRestjson1_serializeDocumentSampleDataS3SourceConfig(v *types.SampleDataS3SourceConfig, value smithyjson.Value) error { 2434 object := value.Object() 2435 defer object.Close() 2436 2437 if v.FileFormatDescriptor != nil { 2438 ok := object.Key("FileFormatDescriptor") 2439 if err := awsRestjson1_serializeDocumentFileFormatDescriptor(v.FileFormatDescriptor, ok); err != nil { 2440 return err 2441 } 2442 } 2443 2444 if v.HistoricalDataPathList != nil { 2445 ok := object.Key("HistoricalDataPathList") 2446 if err := awsRestjson1_serializeDocumentHistoricalDataPathList(v.HistoricalDataPathList, ok); err != nil { 2447 return err 2448 } 2449 } 2450 2451 if v.RoleArn != nil { 2452 ok := object.Key("RoleArn") 2453 ok.String(*v.RoleArn) 2454 } 2455 2456 if v.TemplatedPathList != nil { 2457 ok := object.Key("TemplatedPathList") 2458 if err := awsRestjson1_serializeDocumentTemplatedPathList(v.TemplatedPathList, ok); err != nil { 2459 return err 2460 } 2461 } 2462 2463 return nil 2464} 2465 2466func awsRestjson1_serializeDocumentSecurityGroupIdList(v []string, value smithyjson.Value) error { 2467 array := value.Array() 2468 defer array.Close() 2469 2470 for i := range v { 2471 av := array.Value() 2472 av.String(v[i]) 2473 } 2474 return nil 2475} 2476 2477func awsRestjson1_serializeDocumentSNSConfiguration(v *types.SNSConfiguration, value smithyjson.Value) error { 2478 object := value.Object() 2479 defer object.Close() 2480 2481 if v.RoleArn != nil { 2482 ok := object.Key("RoleArn") 2483 ok.String(*v.RoleArn) 2484 } 2485 2486 if v.SnsTopicArn != nil { 2487 ok := object.Key("SnsTopicArn") 2488 ok.String(*v.SnsTopicArn) 2489 } 2490 2491 return nil 2492} 2493 2494func awsRestjson1_serializeDocumentSubnetIdList(v []string, value smithyjson.Value) error { 2495 array := value.Array() 2496 defer array.Close() 2497 2498 for i := range v { 2499 av := array.Value() 2500 av.String(v[i]) 2501 } 2502 return nil 2503} 2504 2505func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 2506 object := value.Object() 2507 defer object.Close() 2508 2509 for key := range v { 2510 om := object.Key(key) 2511 om.String(v[key]) 2512 } 2513 return nil 2514} 2515 2516func awsRestjson1_serializeDocumentTemplatedPathList(v []string, value smithyjson.Value) error { 2517 array := value.Array() 2518 defer array.Close() 2519 2520 for i := range v { 2521 av := array.Value() 2522 av.String(v[i]) 2523 } 2524 return nil 2525} 2526 2527func awsRestjson1_serializeDocumentTimestampColumn(v *types.TimestampColumn, value smithyjson.Value) error { 2528 object := value.Object() 2529 defer object.Close() 2530 2531 if v.ColumnFormat != nil { 2532 ok := object.Key("ColumnFormat") 2533 ok.String(*v.ColumnFormat) 2534 } 2535 2536 if v.ColumnName != nil { 2537 ok := object.Key("ColumnName") 2538 ok.String(*v.ColumnName) 2539 } 2540 2541 return nil 2542} 2543 2544func awsRestjson1_serializeDocumentVpcConfiguration(v *types.VpcConfiguration, value smithyjson.Value) error { 2545 object := value.Object() 2546 defer object.Close() 2547 2548 if v.SecurityGroupIdList != nil { 2549 ok := object.Key("SecurityGroupIdList") 2550 if err := awsRestjson1_serializeDocumentSecurityGroupIdList(v.SecurityGroupIdList, ok); err != nil { 2551 return err 2552 } 2553 } 2554 2555 if v.SubnetIdList != nil { 2556 ok := object.Key("SubnetIdList") 2557 if err := awsRestjson1_serializeDocumentSubnetIdList(v.SubnetIdList, ok); err != nil { 2558 return err 2559 } 2560 } 2561 2562 return nil 2563} 2564