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