1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package iotanalytics 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/iotanalytics/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_serializeOpBatchPutMessage struct { 19} 20 21func (*awsRestjson1_serializeOpBatchPutMessage) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpBatchPutMessage) 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.(*BatchPutMessageInput) 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("/messages/batch") 40 request.URL.Path = opPath 41 if len(request.URL.RawQuery) > 0 { 42 request.URL.RawQuery = "&" + opQuery 43 } else { 44 request.URL.RawQuery = opQuery 45 } 46 47 request.Method = "POST" 48 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 49 if err != nil { 50 return out, metadata, &smithy.SerializationError{Err: err} 51 } 52 53 restEncoder.SetHeader("Content-Type").String("application/json") 54 55 jsonEncoder := smithyjson.NewEncoder() 56 if err := awsRestjson1_serializeOpDocumentBatchPutMessageInput(input, jsonEncoder.Value); err != nil { 57 return out, metadata, &smithy.SerializationError{Err: err} 58 } 59 60 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 61 return out, metadata, &smithy.SerializationError{Err: err} 62 } 63 64 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 65 return out, metadata, &smithy.SerializationError{Err: err} 66 } 67 in.Request = request 68 69 return next.HandleSerialize(ctx, in) 70} 71func awsRestjson1_serializeOpHttpBindingsBatchPutMessageInput(v *BatchPutMessageInput, encoder *httpbinding.Encoder) error { 72 if v == nil { 73 return fmt.Errorf("unsupported serialization of nil %T", v) 74 } 75 76 return nil 77} 78 79func awsRestjson1_serializeOpDocumentBatchPutMessageInput(v *BatchPutMessageInput, value smithyjson.Value) error { 80 object := value.Object() 81 defer object.Close() 82 83 if v.ChannelName != nil { 84 ok := object.Key("channelName") 85 ok.String(*v.ChannelName) 86 } 87 88 if v.Messages != nil { 89 ok := object.Key("messages") 90 if err := awsRestjson1_serializeDocumentMessages(v.Messages, ok); err != nil { 91 return err 92 } 93 } 94 95 return nil 96} 97 98type awsRestjson1_serializeOpCancelPipelineReprocessing struct { 99} 100 101func (*awsRestjson1_serializeOpCancelPipelineReprocessing) ID() string { 102 return "OperationSerializer" 103} 104 105func (m *awsRestjson1_serializeOpCancelPipelineReprocessing) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 106 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 107) { 108 request, ok := in.Request.(*smithyhttp.Request) 109 if !ok { 110 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 111 } 112 113 input, ok := in.Parameters.(*CancelPipelineReprocessingInput) 114 _ = input 115 if !ok { 116 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 117 } 118 119 opPath, opQuery := httpbinding.SplitURI("/pipelines/{pipelineName}/reprocessing/{reprocessingId}") 120 request.URL.Path = opPath 121 if len(request.URL.RawQuery) > 0 { 122 request.URL.RawQuery = "&" + opQuery 123 } else { 124 request.URL.RawQuery = opQuery 125 } 126 127 request.Method = "DELETE" 128 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 129 if err != nil { 130 return out, metadata, &smithy.SerializationError{Err: err} 131 } 132 133 if err := awsRestjson1_serializeOpHttpBindingsCancelPipelineReprocessingInput(input, restEncoder); err != nil { 134 return out, metadata, &smithy.SerializationError{Err: err} 135 } 136 137 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 138 return out, metadata, &smithy.SerializationError{Err: err} 139 } 140 in.Request = request 141 142 return next.HandleSerialize(ctx, in) 143} 144func awsRestjson1_serializeOpHttpBindingsCancelPipelineReprocessingInput(v *CancelPipelineReprocessingInput, encoder *httpbinding.Encoder) error { 145 if v == nil { 146 return fmt.Errorf("unsupported serialization of nil %T", v) 147 } 148 149 if v.PipelineName == nil || len(*v.PipelineName) == 0 { 150 return &smithy.SerializationError{Err: fmt.Errorf("input member pipelineName must not be empty")} 151 } 152 if v.PipelineName != nil { 153 if err := encoder.SetURI("pipelineName").String(*v.PipelineName); err != nil { 154 return err 155 } 156 } 157 158 if v.ReprocessingId == nil || len(*v.ReprocessingId) == 0 { 159 return &smithy.SerializationError{Err: fmt.Errorf("input member reprocessingId must not be empty")} 160 } 161 if v.ReprocessingId != nil { 162 if err := encoder.SetURI("reprocessingId").String(*v.ReprocessingId); err != nil { 163 return err 164 } 165 } 166 167 return nil 168} 169 170type awsRestjson1_serializeOpCreateChannel struct { 171} 172 173func (*awsRestjson1_serializeOpCreateChannel) ID() string { 174 return "OperationSerializer" 175} 176 177func (m *awsRestjson1_serializeOpCreateChannel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 178 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 179) { 180 request, ok := in.Request.(*smithyhttp.Request) 181 if !ok { 182 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 183 } 184 185 input, ok := in.Parameters.(*CreateChannelInput) 186 _ = input 187 if !ok { 188 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 189 } 190 191 opPath, opQuery := httpbinding.SplitURI("/channels") 192 request.URL.Path = opPath 193 if len(request.URL.RawQuery) > 0 { 194 request.URL.RawQuery = "&" + opQuery 195 } else { 196 request.URL.RawQuery = opQuery 197 } 198 199 request.Method = "POST" 200 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 201 if err != nil { 202 return out, metadata, &smithy.SerializationError{Err: err} 203 } 204 205 restEncoder.SetHeader("Content-Type").String("application/json") 206 207 jsonEncoder := smithyjson.NewEncoder() 208 if err := awsRestjson1_serializeOpDocumentCreateChannelInput(input, jsonEncoder.Value); err != nil { 209 return out, metadata, &smithy.SerializationError{Err: err} 210 } 211 212 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 213 return out, metadata, &smithy.SerializationError{Err: err} 214 } 215 216 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 217 return out, metadata, &smithy.SerializationError{Err: err} 218 } 219 in.Request = request 220 221 return next.HandleSerialize(ctx, in) 222} 223func awsRestjson1_serializeOpHttpBindingsCreateChannelInput(v *CreateChannelInput, encoder *httpbinding.Encoder) error { 224 if v == nil { 225 return fmt.Errorf("unsupported serialization of nil %T", v) 226 } 227 228 return nil 229} 230 231func awsRestjson1_serializeOpDocumentCreateChannelInput(v *CreateChannelInput, value smithyjson.Value) error { 232 object := value.Object() 233 defer object.Close() 234 235 if v.ChannelName != nil { 236 ok := object.Key("channelName") 237 ok.String(*v.ChannelName) 238 } 239 240 if v.ChannelStorage != nil { 241 ok := object.Key("channelStorage") 242 if err := awsRestjson1_serializeDocumentChannelStorage(v.ChannelStorage, ok); err != nil { 243 return err 244 } 245 } 246 247 if v.RetentionPeriod != nil { 248 ok := object.Key("retentionPeriod") 249 if err := awsRestjson1_serializeDocumentRetentionPeriod(v.RetentionPeriod, ok); err != nil { 250 return err 251 } 252 } 253 254 if v.Tags != nil { 255 ok := object.Key("tags") 256 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 257 return err 258 } 259 } 260 261 return nil 262} 263 264type awsRestjson1_serializeOpCreateDataset struct { 265} 266 267func (*awsRestjson1_serializeOpCreateDataset) ID() string { 268 return "OperationSerializer" 269} 270 271func (m *awsRestjson1_serializeOpCreateDataset) 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.(*CreateDatasetInput) 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("/datasets") 286 request.URL.Path = opPath 287 if len(request.URL.RawQuery) > 0 { 288 request.URL.RawQuery = "&" + opQuery 289 } else { 290 request.URL.RawQuery = opQuery 291 } 292 293 request.Method = "POST" 294 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 295 if err != nil { 296 return out, metadata, &smithy.SerializationError{Err: err} 297 } 298 299 restEncoder.SetHeader("Content-Type").String("application/json") 300 301 jsonEncoder := smithyjson.NewEncoder() 302 if err := awsRestjson1_serializeOpDocumentCreateDatasetInput(input, jsonEncoder.Value); err != nil { 303 return out, metadata, &smithy.SerializationError{Err: err} 304 } 305 306 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 307 return out, metadata, &smithy.SerializationError{Err: err} 308 } 309 310 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 311 return out, metadata, &smithy.SerializationError{Err: err} 312 } 313 in.Request = request 314 315 return next.HandleSerialize(ctx, in) 316} 317func awsRestjson1_serializeOpHttpBindingsCreateDatasetInput(v *CreateDatasetInput, encoder *httpbinding.Encoder) error { 318 if v == nil { 319 return fmt.Errorf("unsupported serialization of nil %T", v) 320 } 321 322 return nil 323} 324 325func awsRestjson1_serializeOpDocumentCreateDatasetInput(v *CreateDatasetInput, value smithyjson.Value) error { 326 object := value.Object() 327 defer object.Close() 328 329 if v.Actions != nil { 330 ok := object.Key("actions") 331 if err := awsRestjson1_serializeDocumentDatasetActions(v.Actions, ok); err != nil { 332 return err 333 } 334 } 335 336 if v.ContentDeliveryRules != nil { 337 ok := object.Key("contentDeliveryRules") 338 if err := awsRestjson1_serializeDocumentDatasetContentDeliveryRules(v.ContentDeliveryRules, ok); err != nil { 339 return err 340 } 341 } 342 343 if v.DatasetName != nil { 344 ok := object.Key("datasetName") 345 ok.String(*v.DatasetName) 346 } 347 348 if v.LateDataRules != nil { 349 ok := object.Key("lateDataRules") 350 if err := awsRestjson1_serializeDocumentLateDataRules(v.LateDataRules, ok); err != nil { 351 return err 352 } 353 } 354 355 if v.RetentionPeriod != nil { 356 ok := object.Key("retentionPeriod") 357 if err := awsRestjson1_serializeDocumentRetentionPeriod(v.RetentionPeriod, ok); err != nil { 358 return err 359 } 360 } 361 362 if v.Tags != nil { 363 ok := object.Key("tags") 364 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 365 return err 366 } 367 } 368 369 if v.Triggers != nil { 370 ok := object.Key("triggers") 371 if err := awsRestjson1_serializeDocumentDatasetTriggers(v.Triggers, ok); err != nil { 372 return err 373 } 374 } 375 376 if v.VersioningConfiguration != nil { 377 ok := object.Key("versioningConfiguration") 378 if err := awsRestjson1_serializeDocumentVersioningConfiguration(v.VersioningConfiguration, ok); err != nil { 379 return err 380 } 381 } 382 383 return nil 384} 385 386type awsRestjson1_serializeOpCreateDatasetContent struct { 387} 388 389func (*awsRestjson1_serializeOpCreateDatasetContent) ID() string { 390 return "OperationSerializer" 391} 392 393func (m *awsRestjson1_serializeOpCreateDatasetContent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 394 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 395) { 396 request, ok := in.Request.(*smithyhttp.Request) 397 if !ok { 398 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 399 } 400 401 input, ok := in.Parameters.(*CreateDatasetContentInput) 402 _ = input 403 if !ok { 404 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 405 } 406 407 opPath, opQuery := httpbinding.SplitURI("/datasets/{datasetName}/content") 408 request.URL.Path = opPath 409 if len(request.URL.RawQuery) > 0 { 410 request.URL.RawQuery = "&" + opQuery 411 } else { 412 request.URL.RawQuery = opQuery 413 } 414 415 request.Method = "POST" 416 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 417 if err != nil { 418 return out, metadata, &smithy.SerializationError{Err: err} 419 } 420 421 if err := awsRestjson1_serializeOpHttpBindingsCreateDatasetContentInput(input, restEncoder); err != nil { 422 return out, metadata, &smithy.SerializationError{Err: err} 423 } 424 425 restEncoder.SetHeader("Content-Type").String("application/json") 426 427 jsonEncoder := smithyjson.NewEncoder() 428 if err := awsRestjson1_serializeOpDocumentCreateDatasetContentInput(input, jsonEncoder.Value); err != nil { 429 return out, metadata, &smithy.SerializationError{Err: err} 430 } 431 432 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 433 return out, metadata, &smithy.SerializationError{Err: err} 434 } 435 436 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 437 return out, metadata, &smithy.SerializationError{Err: err} 438 } 439 in.Request = request 440 441 return next.HandleSerialize(ctx, in) 442} 443func awsRestjson1_serializeOpHttpBindingsCreateDatasetContentInput(v *CreateDatasetContentInput, encoder *httpbinding.Encoder) error { 444 if v == nil { 445 return fmt.Errorf("unsupported serialization of nil %T", v) 446 } 447 448 if v.DatasetName == nil || len(*v.DatasetName) == 0 { 449 return &smithy.SerializationError{Err: fmt.Errorf("input member datasetName must not be empty")} 450 } 451 if v.DatasetName != nil { 452 if err := encoder.SetURI("datasetName").String(*v.DatasetName); err != nil { 453 return err 454 } 455 } 456 457 return nil 458} 459 460func awsRestjson1_serializeOpDocumentCreateDatasetContentInput(v *CreateDatasetContentInput, value smithyjson.Value) error { 461 object := value.Object() 462 defer object.Close() 463 464 if v.VersionId != nil { 465 ok := object.Key("versionId") 466 ok.String(*v.VersionId) 467 } 468 469 return nil 470} 471 472type awsRestjson1_serializeOpCreateDatastore struct { 473} 474 475func (*awsRestjson1_serializeOpCreateDatastore) ID() string { 476 return "OperationSerializer" 477} 478 479func (m *awsRestjson1_serializeOpCreateDatastore) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 480 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 481) { 482 request, ok := in.Request.(*smithyhttp.Request) 483 if !ok { 484 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 485 } 486 487 input, ok := in.Parameters.(*CreateDatastoreInput) 488 _ = input 489 if !ok { 490 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 491 } 492 493 opPath, opQuery := httpbinding.SplitURI("/datastores") 494 request.URL.Path = opPath 495 if len(request.URL.RawQuery) > 0 { 496 request.URL.RawQuery = "&" + opQuery 497 } else { 498 request.URL.RawQuery = opQuery 499 } 500 501 request.Method = "POST" 502 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 503 if err != nil { 504 return out, metadata, &smithy.SerializationError{Err: err} 505 } 506 507 restEncoder.SetHeader("Content-Type").String("application/json") 508 509 jsonEncoder := smithyjson.NewEncoder() 510 if err := awsRestjson1_serializeOpDocumentCreateDatastoreInput(input, jsonEncoder.Value); err != nil { 511 return out, metadata, &smithy.SerializationError{Err: err} 512 } 513 514 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 515 return out, metadata, &smithy.SerializationError{Err: err} 516 } 517 518 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 519 return out, metadata, &smithy.SerializationError{Err: err} 520 } 521 in.Request = request 522 523 return next.HandleSerialize(ctx, in) 524} 525func awsRestjson1_serializeOpHttpBindingsCreateDatastoreInput(v *CreateDatastoreInput, encoder *httpbinding.Encoder) error { 526 if v == nil { 527 return fmt.Errorf("unsupported serialization of nil %T", v) 528 } 529 530 return nil 531} 532 533func awsRestjson1_serializeOpDocumentCreateDatastoreInput(v *CreateDatastoreInput, value smithyjson.Value) error { 534 object := value.Object() 535 defer object.Close() 536 537 if v.DatastoreName != nil { 538 ok := object.Key("datastoreName") 539 ok.String(*v.DatastoreName) 540 } 541 542 if v.DatastoreStorage != nil { 543 ok := object.Key("datastoreStorage") 544 if err := awsRestjson1_serializeDocumentDatastoreStorage(v.DatastoreStorage, ok); err != nil { 545 return err 546 } 547 } 548 549 if v.FileFormatConfiguration != nil { 550 ok := object.Key("fileFormatConfiguration") 551 if err := awsRestjson1_serializeDocumentFileFormatConfiguration(v.FileFormatConfiguration, ok); err != nil { 552 return err 553 } 554 } 555 556 if v.RetentionPeriod != nil { 557 ok := object.Key("retentionPeriod") 558 if err := awsRestjson1_serializeDocumentRetentionPeriod(v.RetentionPeriod, ok); err != nil { 559 return err 560 } 561 } 562 563 if v.Tags != nil { 564 ok := object.Key("tags") 565 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 566 return err 567 } 568 } 569 570 return nil 571} 572 573type awsRestjson1_serializeOpCreatePipeline struct { 574} 575 576func (*awsRestjson1_serializeOpCreatePipeline) ID() string { 577 return "OperationSerializer" 578} 579 580func (m *awsRestjson1_serializeOpCreatePipeline) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 581 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 582) { 583 request, ok := in.Request.(*smithyhttp.Request) 584 if !ok { 585 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 586 } 587 588 input, ok := in.Parameters.(*CreatePipelineInput) 589 _ = input 590 if !ok { 591 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 592 } 593 594 opPath, opQuery := httpbinding.SplitURI("/pipelines") 595 request.URL.Path = opPath 596 if len(request.URL.RawQuery) > 0 { 597 request.URL.RawQuery = "&" + opQuery 598 } else { 599 request.URL.RawQuery = opQuery 600 } 601 602 request.Method = "POST" 603 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 604 if err != nil { 605 return out, metadata, &smithy.SerializationError{Err: err} 606 } 607 608 restEncoder.SetHeader("Content-Type").String("application/json") 609 610 jsonEncoder := smithyjson.NewEncoder() 611 if err := awsRestjson1_serializeOpDocumentCreatePipelineInput(input, jsonEncoder.Value); err != nil { 612 return out, metadata, &smithy.SerializationError{Err: err} 613 } 614 615 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 616 return out, metadata, &smithy.SerializationError{Err: err} 617 } 618 619 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 620 return out, metadata, &smithy.SerializationError{Err: err} 621 } 622 in.Request = request 623 624 return next.HandleSerialize(ctx, in) 625} 626func awsRestjson1_serializeOpHttpBindingsCreatePipelineInput(v *CreatePipelineInput, encoder *httpbinding.Encoder) error { 627 if v == nil { 628 return fmt.Errorf("unsupported serialization of nil %T", v) 629 } 630 631 return nil 632} 633 634func awsRestjson1_serializeOpDocumentCreatePipelineInput(v *CreatePipelineInput, value smithyjson.Value) error { 635 object := value.Object() 636 defer object.Close() 637 638 if v.PipelineActivities != nil { 639 ok := object.Key("pipelineActivities") 640 if err := awsRestjson1_serializeDocumentPipelineActivities(v.PipelineActivities, ok); err != nil { 641 return err 642 } 643 } 644 645 if v.PipelineName != nil { 646 ok := object.Key("pipelineName") 647 ok.String(*v.PipelineName) 648 } 649 650 if v.Tags != nil { 651 ok := object.Key("tags") 652 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 653 return err 654 } 655 } 656 657 return nil 658} 659 660type awsRestjson1_serializeOpDeleteChannel struct { 661} 662 663func (*awsRestjson1_serializeOpDeleteChannel) ID() string { 664 return "OperationSerializer" 665} 666 667func (m *awsRestjson1_serializeOpDeleteChannel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 668 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 669) { 670 request, ok := in.Request.(*smithyhttp.Request) 671 if !ok { 672 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 673 } 674 675 input, ok := in.Parameters.(*DeleteChannelInput) 676 _ = input 677 if !ok { 678 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 679 } 680 681 opPath, opQuery := httpbinding.SplitURI("/channels/{channelName}") 682 request.URL.Path = opPath 683 if len(request.URL.RawQuery) > 0 { 684 request.URL.RawQuery = "&" + opQuery 685 } else { 686 request.URL.RawQuery = opQuery 687 } 688 689 request.Method = "DELETE" 690 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 691 if err != nil { 692 return out, metadata, &smithy.SerializationError{Err: err} 693 } 694 695 if err := awsRestjson1_serializeOpHttpBindingsDeleteChannelInput(input, restEncoder); err != nil { 696 return out, metadata, &smithy.SerializationError{Err: err} 697 } 698 699 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 700 return out, metadata, &smithy.SerializationError{Err: err} 701 } 702 in.Request = request 703 704 return next.HandleSerialize(ctx, in) 705} 706func awsRestjson1_serializeOpHttpBindingsDeleteChannelInput(v *DeleteChannelInput, encoder *httpbinding.Encoder) error { 707 if v == nil { 708 return fmt.Errorf("unsupported serialization of nil %T", v) 709 } 710 711 if v.ChannelName == nil || len(*v.ChannelName) == 0 { 712 return &smithy.SerializationError{Err: fmt.Errorf("input member channelName must not be empty")} 713 } 714 if v.ChannelName != nil { 715 if err := encoder.SetURI("channelName").String(*v.ChannelName); err != nil { 716 return err 717 } 718 } 719 720 return nil 721} 722 723type awsRestjson1_serializeOpDeleteDataset struct { 724} 725 726func (*awsRestjson1_serializeOpDeleteDataset) ID() string { 727 return "OperationSerializer" 728} 729 730func (m *awsRestjson1_serializeOpDeleteDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 731 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 732) { 733 request, ok := in.Request.(*smithyhttp.Request) 734 if !ok { 735 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 736 } 737 738 input, ok := in.Parameters.(*DeleteDatasetInput) 739 _ = input 740 if !ok { 741 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 742 } 743 744 opPath, opQuery := httpbinding.SplitURI("/datasets/{datasetName}") 745 request.URL.Path = opPath 746 if len(request.URL.RawQuery) > 0 { 747 request.URL.RawQuery = "&" + opQuery 748 } else { 749 request.URL.RawQuery = opQuery 750 } 751 752 request.Method = "DELETE" 753 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 754 if err != nil { 755 return out, metadata, &smithy.SerializationError{Err: err} 756 } 757 758 if err := awsRestjson1_serializeOpHttpBindingsDeleteDatasetInput(input, restEncoder); err != nil { 759 return out, metadata, &smithy.SerializationError{Err: err} 760 } 761 762 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 763 return out, metadata, &smithy.SerializationError{Err: err} 764 } 765 in.Request = request 766 767 return next.HandleSerialize(ctx, in) 768} 769func awsRestjson1_serializeOpHttpBindingsDeleteDatasetInput(v *DeleteDatasetInput, encoder *httpbinding.Encoder) error { 770 if v == nil { 771 return fmt.Errorf("unsupported serialization of nil %T", v) 772 } 773 774 if v.DatasetName == nil || len(*v.DatasetName) == 0 { 775 return &smithy.SerializationError{Err: fmt.Errorf("input member datasetName must not be empty")} 776 } 777 if v.DatasetName != nil { 778 if err := encoder.SetURI("datasetName").String(*v.DatasetName); err != nil { 779 return err 780 } 781 } 782 783 return nil 784} 785 786type awsRestjson1_serializeOpDeleteDatasetContent struct { 787} 788 789func (*awsRestjson1_serializeOpDeleteDatasetContent) ID() string { 790 return "OperationSerializer" 791} 792 793func (m *awsRestjson1_serializeOpDeleteDatasetContent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 794 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 795) { 796 request, ok := in.Request.(*smithyhttp.Request) 797 if !ok { 798 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 799 } 800 801 input, ok := in.Parameters.(*DeleteDatasetContentInput) 802 _ = input 803 if !ok { 804 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 805 } 806 807 opPath, opQuery := httpbinding.SplitURI("/datasets/{datasetName}/content") 808 request.URL.Path = opPath 809 if len(request.URL.RawQuery) > 0 { 810 request.URL.RawQuery = "&" + opQuery 811 } else { 812 request.URL.RawQuery = opQuery 813 } 814 815 request.Method = "DELETE" 816 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 817 if err != nil { 818 return out, metadata, &smithy.SerializationError{Err: err} 819 } 820 821 if err := awsRestjson1_serializeOpHttpBindingsDeleteDatasetContentInput(input, restEncoder); err != nil { 822 return out, metadata, &smithy.SerializationError{Err: err} 823 } 824 825 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 826 return out, metadata, &smithy.SerializationError{Err: err} 827 } 828 in.Request = request 829 830 return next.HandleSerialize(ctx, in) 831} 832func awsRestjson1_serializeOpHttpBindingsDeleteDatasetContentInput(v *DeleteDatasetContentInput, encoder *httpbinding.Encoder) error { 833 if v == nil { 834 return fmt.Errorf("unsupported serialization of nil %T", v) 835 } 836 837 if v.DatasetName == nil || len(*v.DatasetName) == 0 { 838 return &smithy.SerializationError{Err: fmt.Errorf("input member datasetName must not be empty")} 839 } 840 if v.DatasetName != nil { 841 if err := encoder.SetURI("datasetName").String(*v.DatasetName); err != nil { 842 return err 843 } 844 } 845 846 if v.VersionId != nil { 847 encoder.SetQuery("versionId").String(*v.VersionId) 848 } 849 850 return nil 851} 852 853type awsRestjson1_serializeOpDeleteDatastore struct { 854} 855 856func (*awsRestjson1_serializeOpDeleteDatastore) ID() string { 857 return "OperationSerializer" 858} 859 860func (m *awsRestjson1_serializeOpDeleteDatastore) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 861 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 862) { 863 request, ok := in.Request.(*smithyhttp.Request) 864 if !ok { 865 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 866 } 867 868 input, ok := in.Parameters.(*DeleteDatastoreInput) 869 _ = input 870 if !ok { 871 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 872 } 873 874 opPath, opQuery := httpbinding.SplitURI("/datastores/{datastoreName}") 875 request.URL.Path = opPath 876 if len(request.URL.RawQuery) > 0 { 877 request.URL.RawQuery = "&" + opQuery 878 } else { 879 request.URL.RawQuery = opQuery 880 } 881 882 request.Method = "DELETE" 883 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 884 if err != nil { 885 return out, metadata, &smithy.SerializationError{Err: err} 886 } 887 888 if err := awsRestjson1_serializeOpHttpBindingsDeleteDatastoreInput(input, restEncoder); err != nil { 889 return out, metadata, &smithy.SerializationError{Err: err} 890 } 891 892 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 893 return out, metadata, &smithy.SerializationError{Err: err} 894 } 895 in.Request = request 896 897 return next.HandleSerialize(ctx, in) 898} 899func awsRestjson1_serializeOpHttpBindingsDeleteDatastoreInput(v *DeleteDatastoreInput, encoder *httpbinding.Encoder) error { 900 if v == nil { 901 return fmt.Errorf("unsupported serialization of nil %T", v) 902 } 903 904 if v.DatastoreName == nil || len(*v.DatastoreName) == 0 { 905 return &smithy.SerializationError{Err: fmt.Errorf("input member datastoreName must not be empty")} 906 } 907 if v.DatastoreName != nil { 908 if err := encoder.SetURI("datastoreName").String(*v.DatastoreName); err != nil { 909 return err 910 } 911 } 912 913 return nil 914} 915 916type awsRestjson1_serializeOpDeletePipeline struct { 917} 918 919func (*awsRestjson1_serializeOpDeletePipeline) ID() string { 920 return "OperationSerializer" 921} 922 923func (m *awsRestjson1_serializeOpDeletePipeline) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 924 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 925) { 926 request, ok := in.Request.(*smithyhttp.Request) 927 if !ok { 928 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 929 } 930 931 input, ok := in.Parameters.(*DeletePipelineInput) 932 _ = input 933 if !ok { 934 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 935 } 936 937 opPath, opQuery := httpbinding.SplitURI("/pipelines/{pipelineName}") 938 request.URL.Path = opPath 939 if len(request.URL.RawQuery) > 0 { 940 request.URL.RawQuery = "&" + opQuery 941 } else { 942 request.URL.RawQuery = opQuery 943 } 944 945 request.Method = "DELETE" 946 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 947 if err != nil { 948 return out, metadata, &smithy.SerializationError{Err: err} 949 } 950 951 if err := awsRestjson1_serializeOpHttpBindingsDeletePipelineInput(input, restEncoder); err != nil { 952 return out, metadata, &smithy.SerializationError{Err: err} 953 } 954 955 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 956 return out, metadata, &smithy.SerializationError{Err: err} 957 } 958 in.Request = request 959 960 return next.HandleSerialize(ctx, in) 961} 962func awsRestjson1_serializeOpHttpBindingsDeletePipelineInput(v *DeletePipelineInput, encoder *httpbinding.Encoder) error { 963 if v == nil { 964 return fmt.Errorf("unsupported serialization of nil %T", v) 965 } 966 967 if v.PipelineName == nil || len(*v.PipelineName) == 0 { 968 return &smithy.SerializationError{Err: fmt.Errorf("input member pipelineName must not be empty")} 969 } 970 if v.PipelineName != nil { 971 if err := encoder.SetURI("pipelineName").String(*v.PipelineName); err != nil { 972 return err 973 } 974 } 975 976 return nil 977} 978 979type awsRestjson1_serializeOpDescribeChannel struct { 980} 981 982func (*awsRestjson1_serializeOpDescribeChannel) ID() string { 983 return "OperationSerializer" 984} 985 986func (m *awsRestjson1_serializeOpDescribeChannel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 987 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 988) { 989 request, ok := in.Request.(*smithyhttp.Request) 990 if !ok { 991 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 992 } 993 994 input, ok := in.Parameters.(*DescribeChannelInput) 995 _ = input 996 if !ok { 997 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 998 } 999 1000 opPath, opQuery := httpbinding.SplitURI("/channels/{channelName}") 1001 request.URL.Path = opPath 1002 if len(request.URL.RawQuery) > 0 { 1003 request.URL.RawQuery = "&" + opQuery 1004 } else { 1005 request.URL.RawQuery = opQuery 1006 } 1007 1008 request.Method = "GET" 1009 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1010 if err != nil { 1011 return out, metadata, &smithy.SerializationError{Err: err} 1012 } 1013 1014 if err := awsRestjson1_serializeOpHttpBindingsDescribeChannelInput(input, restEncoder); err != nil { 1015 return out, metadata, &smithy.SerializationError{Err: err} 1016 } 1017 1018 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1019 return out, metadata, &smithy.SerializationError{Err: err} 1020 } 1021 in.Request = request 1022 1023 return next.HandleSerialize(ctx, in) 1024} 1025func awsRestjson1_serializeOpHttpBindingsDescribeChannelInput(v *DescribeChannelInput, encoder *httpbinding.Encoder) error { 1026 if v == nil { 1027 return fmt.Errorf("unsupported serialization of nil %T", v) 1028 } 1029 1030 if v.ChannelName == nil || len(*v.ChannelName) == 0 { 1031 return &smithy.SerializationError{Err: fmt.Errorf("input member channelName must not be empty")} 1032 } 1033 if v.ChannelName != nil { 1034 if err := encoder.SetURI("channelName").String(*v.ChannelName); err != nil { 1035 return err 1036 } 1037 } 1038 1039 if v.IncludeStatistics { 1040 encoder.SetQuery("includeStatistics").Boolean(v.IncludeStatistics) 1041 } 1042 1043 return nil 1044} 1045 1046type awsRestjson1_serializeOpDescribeDataset struct { 1047} 1048 1049func (*awsRestjson1_serializeOpDescribeDataset) ID() string { 1050 return "OperationSerializer" 1051} 1052 1053func (m *awsRestjson1_serializeOpDescribeDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1054 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1055) { 1056 request, ok := in.Request.(*smithyhttp.Request) 1057 if !ok { 1058 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1059 } 1060 1061 input, ok := in.Parameters.(*DescribeDatasetInput) 1062 _ = input 1063 if !ok { 1064 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1065 } 1066 1067 opPath, opQuery := httpbinding.SplitURI("/datasets/{datasetName}") 1068 request.URL.Path = opPath 1069 if len(request.URL.RawQuery) > 0 { 1070 request.URL.RawQuery = "&" + opQuery 1071 } else { 1072 request.URL.RawQuery = opQuery 1073 } 1074 1075 request.Method = "GET" 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 if err := awsRestjson1_serializeOpHttpBindingsDescribeDatasetInput(input, restEncoder); err != nil { 1082 return out, metadata, &smithy.SerializationError{Err: err} 1083 } 1084 1085 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1086 return out, metadata, &smithy.SerializationError{Err: err} 1087 } 1088 in.Request = request 1089 1090 return next.HandleSerialize(ctx, in) 1091} 1092func awsRestjson1_serializeOpHttpBindingsDescribeDatasetInput(v *DescribeDatasetInput, encoder *httpbinding.Encoder) error { 1093 if v == nil { 1094 return fmt.Errorf("unsupported serialization of nil %T", v) 1095 } 1096 1097 if v.DatasetName == nil || len(*v.DatasetName) == 0 { 1098 return &smithy.SerializationError{Err: fmt.Errorf("input member datasetName must not be empty")} 1099 } 1100 if v.DatasetName != nil { 1101 if err := encoder.SetURI("datasetName").String(*v.DatasetName); err != nil { 1102 return err 1103 } 1104 } 1105 1106 return nil 1107} 1108 1109type awsRestjson1_serializeOpDescribeDatastore struct { 1110} 1111 1112func (*awsRestjson1_serializeOpDescribeDatastore) ID() string { 1113 return "OperationSerializer" 1114} 1115 1116func (m *awsRestjson1_serializeOpDescribeDatastore) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1117 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1118) { 1119 request, ok := in.Request.(*smithyhttp.Request) 1120 if !ok { 1121 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1122 } 1123 1124 input, ok := in.Parameters.(*DescribeDatastoreInput) 1125 _ = input 1126 if !ok { 1127 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1128 } 1129 1130 opPath, opQuery := httpbinding.SplitURI("/datastores/{datastoreName}") 1131 request.URL.Path = opPath 1132 if len(request.URL.RawQuery) > 0 { 1133 request.URL.RawQuery = "&" + opQuery 1134 } else { 1135 request.URL.RawQuery = opQuery 1136 } 1137 1138 request.Method = "GET" 1139 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1140 if err != nil { 1141 return out, metadata, &smithy.SerializationError{Err: err} 1142 } 1143 1144 if err := awsRestjson1_serializeOpHttpBindingsDescribeDatastoreInput(input, restEncoder); err != nil { 1145 return out, metadata, &smithy.SerializationError{Err: err} 1146 } 1147 1148 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1149 return out, metadata, &smithy.SerializationError{Err: err} 1150 } 1151 in.Request = request 1152 1153 return next.HandleSerialize(ctx, in) 1154} 1155func awsRestjson1_serializeOpHttpBindingsDescribeDatastoreInput(v *DescribeDatastoreInput, encoder *httpbinding.Encoder) error { 1156 if v == nil { 1157 return fmt.Errorf("unsupported serialization of nil %T", v) 1158 } 1159 1160 if v.DatastoreName == nil || len(*v.DatastoreName) == 0 { 1161 return &smithy.SerializationError{Err: fmt.Errorf("input member datastoreName must not be empty")} 1162 } 1163 if v.DatastoreName != nil { 1164 if err := encoder.SetURI("datastoreName").String(*v.DatastoreName); err != nil { 1165 return err 1166 } 1167 } 1168 1169 if v.IncludeStatistics { 1170 encoder.SetQuery("includeStatistics").Boolean(v.IncludeStatistics) 1171 } 1172 1173 return nil 1174} 1175 1176type awsRestjson1_serializeOpDescribeLoggingOptions struct { 1177} 1178 1179func (*awsRestjson1_serializeOpDescribeLoggingOptions) ID() string { 1180 return "OperationSerializer" 1181} 1182 1183func (m *awsRestjson1_serializeOpDescribeLoggingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1184 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1185) { 1186 request, ok := in.Request.(*smithyhttp.Request) 1187 if !ok { 1188 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1189 } 1190 1191 input, ok := in.Parameters.(*DescribeLoggingOptionsInput) 1192 _ = input 1193 if !ok { 1194 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1195 } 1196 1197 opPath, opQuery := httpbinding.SplitURI("/logging") 1198 request.URL.Path = opPath 1199 if len(request.URL.RawQuery) > 0 { 1200 request.URL.RawQuery = "&" + opQuery 1201 } else { 1202 request.URL.RawQuery = opQuery 1203 } 1204 1205 request.Method = "GET" 1206 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1207 if err != nil { 1208 return out, metadata, &smithy.SerializationError{Err: err} 1209 } 1210 1211 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1212 return out, metadata, &smithy.SerializationError{Err: err} 1213 } 1214 in.Request = request 1215 1216 return next.HandleSerialize(ctx, in) 1217} 1218func awsRestjson1_serializeOpHttpBindingsDescribeLoggingOptionsInput(v *DescribeLoggingOptionsInput, encoder *httpbinding.Encoder) error { 1219 if v == nil { 1220 return fmt.Errorf("unsupported serialization of nil %T", v) 1221 } 1222 1223 return nil 1224} 1225 1226type awsRestjson1_serializeOpDescribePipeline struct { 1227} 1228 1229func (*awsRestjson1_serializeOpDescribePipeline) ID() string { 1230 return "OperationSerializer" 1231} 1232 1233func (m *awsRestjson1_serializeOpDescribePipeline) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1234 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1235) { 1236 request, ok := in.Request.(*smithyhttp.Request) 1237 if !ok { 1238 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1239 } 1240 1241 input, ok := in.Parameters.(*DescribePipelineInput) 1242 _ = input 1243 if !ok { 1244 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1245 } 1246 1247 opPath, opQuery := httpbinding.SplitURI("/pipelines/{pipelineName}") 1248 request.URL.Path = opPath 1249 if len(request.URL.RawQuery) > 0 { 1250 request.URL.RawQuery = "&" + opQuery 1251 } else { 1252 request.URL.RawQuery = opQuery 1253 } 1254 1255 request.Method = "GET" 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 if err := awsRestjson1_serializeOpHttpBindingsDescribePipelineInput(input, restEncoder); err != nil { 1262 return out, metadata, &smithy.SerializationError{Err: err} 1263 } 1264 1265 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1266 return out, metadata, &smithy.SerializationError{Err: err} 1267 } 1268 in.Request = request 1269 1270 return next.HandleSerialize(ctx, in) 1271} 1272func awsRestjson1_serializeOpHttpBindingsDescribePipelineInput(v *DescribePipelineInput, encoder *httpbinding.Encoder) error { 1273 if v == nil { 1274 return fmt.Errorf("unsupported serialization of nil %T", v) 1275 } 1276 1277 if v.PipelineName == nil || len(*v.PipelineName) == 0 { 1278 return &smithy.SerializationError{Err: fmt.Errorf("input member pipelineName must not be empty")} 1279 } 1280 if v.PipelineName != nil { 1281 if err := encoder.SetURI("pipelineName").String(*v.PipelineName); err != nil { 1282 return err 1283 } 1284 } 1285 1286 return nil 1287} 1288 1289type awsRestjson1_serializeOpGetDatasetContent struct { 1290} 1291 1292func (*awsRestjson1_serializeOpGetDatasetContent) ID() string { 1293 return "OperationSerializer" 1294} 1295 1296func (m *awsRestjson1_serializeOpGetDatasetContent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1297 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1298) { 1299 request, ok := in.Request.(*smithyhttp.Request) 1300 if !ok { 1301 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1302 } 1303 1304 input, ok := in.Parameters.(*GetDatasetContentInput) 1305 _ = input 1306 if !ok { 1307 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1308 } 1309 1310 opPath, opQuery := httpbinding.SplitURI("/datasets/{datasetName}/content") 1311 request.URL.Path = opPath 1312 if len(request.URL.RawQuery) > 0 { 1313 request.URL.RawQuery = "&" + opQuery 1314 } else { 1315 request.URL.RawQuery = opQuery 1316 } 1317 1318 request.Method = "GET" 1319 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1320 if err != nil { 1321 return out, metadata, &smithy.SerializationError{Err: err} 1322 } 1323 1324 if err := awsRestjson1_serializeOpHttpBindingsGetDatasetContentInput(input, restEncoder); err != nil { 1325 return out, metadata, &smithy.SerializationError{Err: err} 1326 } 1327 1328 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1329 return out, metadata, &smithy.SerializationError{Err: err} 1330 } 1331 in.Request = request 1332 1333 return next.HandleSerialize(ctx, in) 1334} 1335func awsRestjson1_serializeOpHttpBindingsGetDatasetContentInput(v *GetDatasetContentInput, encoder *httpbinding.Encoder) error { 1336 if v == nil { 1337 return fmt.Errorf("unsupported serialization of nil %T", v) 1338 } 1339 1340 if v.DatasetName == nil || len(*v.DatasetName) == 0 { 1341 return &smithy.SerializationError{Err: fmt.Errorf("input member datasetName must not be empty")} 1342 } 1343 if v.DatasetName != nil { 1344 if err := encoder.SetURI("datasetName").String(*v.DatasetName); err != nil { 1345 return err 1346 } 1347 } 1348 1349 if v.VersionId != nil { 1350 encoder.SetQuery("versionId").String(*v.VersionId) 1351 } 1352 1353 return nil 1354} 1355 1356type awsRestjson1_serializeOpListChannels struct { 1357} 1358 1359func (*awsRestjson1_serializeOpListChannels) ID() string { 1360 return "OperationSerializer" 1361} 1362 1363func (m *awsRestjson1_serializeOpListChannels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1364 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1365) { 1366 request, ok := in.Request.(*smithyhttp.Request) 1367 if !ok { 1368 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1369 } 1370 1371 input, ok := in.Parameters.(*ListChannelsInput) 1372 _ = input 1373 if !ok { 1374 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1375 } 1376 1377 opPath, opQuery := httpbinding.SplitURI("/channels") 1378 request.URL.Path = opPath 1379 if len(request.URL.RawQuery) > 0 { 1380 request.URL.RawQuery = "&" + opQuery 1381 } else { 1382 request.URL.RawQuery = opQuery 1383 } 1384 1385 request.Method = "GET" 1386 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1387 if err != nil { 1388 return out, metadata, &smithy.SerializationError{Err: err} 1389 } 1390 1391 if err := awsRestjson1_serializeOpHttpBindingsListChannelsInput(input, restEncoder); err != nil { 1392 return out, metadata, &smithy.SerializationError{Err: err} 1393 } 1394 1395 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1396 return out, metadata, &smithy.SerializationError{Err: err} 1397 } 1398 in.Request = request 1399 1400 return next.HandleSerialize(ctx, in) 1401} 1402func awsRestjson1_serializeOpHttpBindingsListChannelsInput(v *ListChannelsInput, encoder *httpbinding.Encoder) error { 1403 if v == nil { 1404 return fmt.Errorf("unsupported serialization of nil %T", v) 1405 } 1406 1407 if v.MaxResults != nil { 1408 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1409 } 1410 1411 if v.NextToken != nil { 1412 encoder.SetQuery("nextToken").String(*v.NextToken) 1413 } 1414 1415 return nil 1416} 1417 1418type awsRestjson1_serializeOpListDatasetContents struct { 1419} 1420 1421func (*awsRestjson1_serializeOpListDatasetContents) ID() string { 1422 return "OperationSerializer" 1423} 1424 1425func (m *awsRestjson1_serializeOpListDatasetContents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1426 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1427) { 1428 request, ok := in.Request.(*smithyhttp.Request) 1429 if !ok { 1430 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1431 } 1432 1433 input, ok := in.Parameters.(*ListDatasetContentsInput) 1434 _ = input 1435 if !ok { 1436 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1437 } 1438 1439 opPath, opQuery := httpbinding.SplitURI("/datasets/{datasetName}/contents") 1440 request.URL.Path = opPath 1441 if len(request.URL.RawQuery) > 0 { 1442 request.URL.RawQuery = "&" + opQuery 1443 } else { 1444 request.URL.RawQuery = opQuery 1445 } 1446 1447 request.Method = "GET" 1448 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1449 if err != nil { 1450 return out, metadata, &smithy.SerializationError{Err: err} 1451 } 1452 1453 if err := awsRestjson1_serializeOpHttpBindingsListDatasetContentsInput(input, restEncoder); err != nil { 1454 return out, metadata, &smithy.SerializationError{Err: err} 1455 } 1456 1457 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1458 return out, metadata, &smithy.SerializationError{Err: err} 1459 } 1460 in.Request = request 1461 1462 return next.HandleSerialize(ctx, in) 1463} 1464func awsRestjson1_serializeOpHttpBindingsListDatasetContentsInput(v *ListDatasetContentsInput, encoder *httpbinding.Encoder) error { 1465 if v == nil { 1466 return fmt.Errorf("unsupported serialization of nil %T", v) 1467 } 1468 1469 if v.DatasetName == nil || len(*v.DatasetName) == 0 { 1470 return &smithy.SerializationError{Err: fmt.Errorf("input member datasetName must not be empty")} 1471 } 1472 if v.DatasetName != nil { 1473 if err := encoder.SetURI("datasetName").String(*v.DatasetName); err != nil { 1474 return err 1475 } 1476 } 1477 1478 if v.MaxResults != nil { 1479 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1480 } 1481 1482 if v.NextToken != nil { 1483 encoder.SetQuery("nextToken").String(*v.NextToken) 1484 } 1485 1486 if v.ScheduledBefore != nil { 1487 encoder.SetQuery("scheduledBefore").String(smithytime.FormatDateTime(*v.ScheduledBefore)) 1488 } 1489 1490 if v.ScheduledOnOrAfter != nil { 1491 encoder.SetQuery("scheduledOnOrAfter").String(smithytime.FormatDateTime(*v.ScheduledOnOrAfter)) 1492 } 1493 1494 return nil 1495} 1496 1497type awsRestjson1_serializeOpListDatasets struct { 1498} 1499 1500func (*awsRestjson1_serializeOpListDatasets) ID() string { 1501 return "OperationSerializer" 1502} 1503 1504func (m *awsRestjson1_serializeOpListDatasets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1505 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1506) { 1507 request, ok := in.Request.(*smithyhttp.Request) 1508 if !ok { 1509 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1510 } 1511 1512 input, ok := in.Parameters.(*ListDatasetsInput) 1513 _ = input 1514 if !ok { 1515 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1516 } 1517 1518 opPath, opQuery := httpbinding.SplitURI("/datasets") 1519 request.URL.Path = opPath 1520 if len(request.URL.RawQuery) > 0 { 1521 request.URL.RawQuery = "&" + opQuery 1522 } else { 1523 request.URL.RawQuery = opQuery 1524 } 1525 1526 request.Method = "GET" 1527 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1528 if err != nil { 1529 return out, metadata, &smithy.SerializationError{Err: err} 1530 } 1531 1532 if err := awsRestjson1_serializeOpHttpBindingsListDatasetsInput(input, restEncoder); err != nil { 1533 return out, metadata, &smithy.SerializationError{Err: err} 1534 } 1535 1536 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1537 return out, metadata, &smithy.SerializationError{Err: err} 1538 } 1539 in.Request = request 1540 1541 return next.HandleSerialize(ctx, in) 1542} 1543func awsRestjson1_serializeOpHttpBindingsListDatasetsInput(v *ListDatasetsInput, encoder *httpbinding.Encoder) error { 1544 if v == nil { 1545 return fmt.Errorf("unsupported serialization of nil %T", v) 1546 } 1547 1548 if v.MaxResults != nil { 1549 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1550 } 1551 1552 if v.NextToken != nil { 1553 encoder.SetQuery("nextToken").String(*v.NextToken) 1554 } 1555 1556 return nil 1557} 1558 1559type awsRestjson1_serializeOpListDatastores struct { 1560} 1561 1562func (*awsRestjson1_serializeOpListDatastores) ID() string { 1563 return "OperationSerializer" 1564} 1565 1566func (m *awsRestjson1_serializeOpListDatastores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1567 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1568) { 1569 request, ok := in.Request.(*smithyhttp.Request) 1570 if !ok { 1571 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1572 } 1573 1574 input, ok := in.Parameters.(*ListDatastoresInput) 1575 _ = input 1576 if !ok { 1577 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1578 } 1579 1580 opPath, opQuery := httpbinding.SplitURI("/datastores") 1581 request.URL.Path = opPath 1582 if len(request.URL.RawQuery) > 0 { 1583 request.URL.RawQuery = "&" + opQuery 1584 } else { 1585 request.URL.RawQuery = opQuery 1586 } 1587 1588 request.Method = "GET" 1589 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1590 if err != nil { 1591 return out, metadata, &smithy.SerializationError{Err: err} 1592 } 1593 1594 if err := awsRestjson1_serializeOpHttpBindingsListDatastoresInput(input, restEncoder); err != nil { 1595 return out, metadata, &smithy.SerializationError{Err: err} 1596 } 1597 1598 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1599 return out, metadata, &smithy.SerializationError{Err: err} 1600 } 1601 in.Request = request 1602 1603 return next.HandleSerialize(ctx, in) 1604} 1605func awsRestjson1_serializeOpHttpBindingsListDatastoresInput(v *ListDatastoresInput, encoder *httpbinding.Encoder) error { 1606 if v == nil { 1607 return fmt.Errorf("unsupported serialization of nil %T", v) 1608 } 1609 1610 if v.MaxResults != nil { 1611 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1612 } 1613 1614 if v.NextToken != nil { 1615 encoder.SetQuery("nextToken").String(*v.NextToken) 1616 } 1617 1618 return nil 1619} 1620 1621type awsRestjson1_serializeOpListPipelines struct { 1622} 1623 1624func (*awsRestjson1_serializeOpListPipelines) ID() string { 1625 return "OperationSerializer" 1626} 1627 1628func (m *awsRestjson1_serializeOpListPipelines) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1629 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1630) { 1631 request, ok := in.Request.(*smithyhttp.Request) 1632 if !ok { 1633 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1634 } 1635 1636 input, ok := in.Parameters.(*ListPipelinesInput) 1637 _ = input 1638 if !ok { 1639 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1640 } 1641 1642 opPath, opQuery := httpbinding.SplitURI("/pipelines") 1643 request.URL.Path = opPath 1644 if len(request.URL.RawQuery) > 0 { 1645 request.URL.RawQuery = "&" + opQuery 1646 } else { 1647 request.URL.RawQuery = opQuery 1648 } 1649 1650 request.Method = "GET" 1651 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1652 if err != nil { 1653 return out, metadata, &smithy.SerializationError{Err: err} 1654 } 1655 1656 if err := awsRestjson1_serializeOpHttpBindingsListPipelinesInput(input, restEncoder); err != nil { 1657 return out, metadata, &smithy.SerializationError{Err: err} 1658 } 1659 1660 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1661 return out, metadata, &smithy.SerializationError{Err: err} 1662 } 1663 in.Request = request 1664 1665 return next.HandleSerialize(ctx, in) 1666} 1667func awsRestjson1_serializeOpHttpBindingsListPipelinesInput(v *ListPipelinesInput, encoder *httpbinding.Encoder) error { 1668 if v == nil { 1669 return fmt.Errorf("unsupported serialization of nil %T", v) 1670 } 1671 1672 if v.MaxResults != nil { 1673 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1674 } 1675 1676 if v.NextToken != nil { 1677 encoder.SetQuery("nextToken").String(*v.NextToken) 1678 } 1679 1680 return nil 1681} 1682 1683type awsRestjson1_serializeOpListTagsForResource struct { 1684} 1685 1686func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 1687 return "OperationSerializer" 1688} 1689 1690func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1691 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1692) { 1693 request, ok := in.Request.(*smithyhttp.Request) 1694 if !ok { 1695 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1696 } 1697 1698 input, ok := in.Parameters.(*ListTagsForResourceInput) 1699 _ = input 1700 if !ok { 1701 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1702 } 1703 1704 opPath, opQuery := httpbinding.SplitURI("/tags") 1705 request.URL.Path = opPath 1706 if len(request.URL.RawQuery) > 0 { 1707 request.URL.RawQuery = "&" + opQuery 1708 } else { 1709 request.URL.RawQuery = opQuery 1710 } 1711 1712 request.Method = "GET" 1713 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1714 if err != nil { 1715 return out, metadata, &smithy.SerializationError{Err: err} 1716 } 1717 1718 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 1719 return out, metadata, &smithy.SerializationError{Err: err} 1720 } 1721 1722 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1723 return out, metadata, &smithy.SerializationError{Err: err} 1724 } 1725 in.Request = request 1726 1727 return next.HandleSerialize(ctx, in) 1728} 1729func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1730 if v == nil { 1731 return fmt.Errorf("unsupported serialization of nil %T", v) 1732 } 1733 1734 if v.ResourceArn != nil { 1735 encoder.SetQuery("resourceArn").String(*v.ResourceArn) 1736 } 1737 1738 return nil 1739} 1740 1741type awsRestjson1_serializeOpPutLoggingOptions struct { 1742} 1743 1744func (*awsRestjson1_serializeOpPutLoggingOptions) ID() string { 1745 return "OperationSerializer" 1746} 1747 1748func (m *awsRestjson1_serializeOpPutLoggingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1749 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1750) { 1751 request, ok := in.Request.(*smithyhttp.Request) 1752 if !ok { 1753 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1754 } 1755 1756 input, ok := in.Parameters.(*PutLoggingOptionsInput) 1757 _ = input 1758 if !ok { 1759 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1760 } 1761 1762 opPath, opQuery := httpbinding.SplitURI("/logging") 1763 request.URL.Path = opPath 1764 if len(request.URL.RawQuery) > 0 { 1765 request.URL.RawQuery = "&" + opQuery 1766 } else { 1767 request.URL.RawQuery = opQuery 1768 } 1769 1770 request.Method = "PUT" 1771 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1772 if err != nil { 1773 return out, metadata, &smithy.SerializationError{Err: err} 1774 } 1775 1776 restEncoder.SetHeader("Content-Type").String("application/json") 1777 1778 jsonEncoder := smithyjson.NewEncoder() 1779 if err := awsRestjson1_serializeOpDocumentPutLoggingOptionsInput(input, jsonEncoder.Value); err != nil { 1780 return out, metadata, &smithy.SerializationError{Err: err} 1781 } 1782 1783 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1784 return out, metadata, &smithy.SerializationError{Err: err} 1785 } 1786 1787 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1788 return out, metadata, &smithy.SerializationError{Err: err} 1789 } 1790 in.Request = request 1791 1792 return next.HandleSerialize(ctx, in) 1793} 1794func awsRestjson1_serializeOpHttpBindingsPutLoggingOptionsInput(v *PutLoggingOptionsInput, encoder *httpbinding.Encoder) error { 1795 if v == nil { 1796 return fmt.Errorf("unsupported serialization of nil %T", v) 1797 } 1798 1799 return nil 1800} 1801 1802func awsRestjson1_serializeOpDocumentPutLoggingOptionsInput(v *PutLoggingOptionsInput, value smithyjson.Value) error { 1803 object := value.Object() 1804 defer object.Close() 1805 1806 if v.LoggingOptions != nil { 1807 ok := object.Key("loggingOptions") 1808 if err := awsRestjson1_serializeDocumentLoggingOptions(v.LoggingOptions, ok); err != nil { 1809 return err 1810 } 1811 } 1812 1813 return nil 1814} 1815 1816type awsRestjson1_serializeOpRunPipelineActivity struct { 1817} 1818 1819func (*awsRestjson1_serializeOpRunPipelineActivity) ID() string { 1820 return "OperationSerializer" 1821} 1822 1823func (m *awsRestjson1_serializeOpRunPipelineActivity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1824 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1825) { 1826 request, ok := in.Request.(*smithyhttp.Request) 1827 if !ok { 1828 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1829 } 1830 1831 input, ok := in.Parameters.(*RunPipelineActivityInput) 1832 _ = input 1833 if !ok { 1834 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1835 } 1836 1837 opPath, opQuery := httpbinding.SplitURI("/pipelineactivities/run") 1838 request.URL.Path = opPath 1839 if len(request.URL.RawQuery) > 0 { 1840 request.URL.RawQuery = "&" + opQuery 1841 } else { 1842 request.URL.RawQuery = opQuery 1843 } 1844 1845 request.Method = "POST" 1846 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1847 if err != nil { 1848 return out, metadata, &smithy.SerializationError{Err: err} 1849 } 1850 1851 restEncoder.SetHeader("Content-Type").String("application/json") 1852 1853 jsonEncoder := smithyjson.NewEncoder() 1854 if err := awsRestjson1_serializeOpDocumentRunPipelineActivityInput(input, jsonEncoder.Value); err != nil { 1855 return out, metadata, &smithy.SerializationError{Err: err} 1856 } 1857 1858 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1859 return out, metadata, &smithy.SerializationError{Err: err} 1860 } 1861 1862 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1863 return out, metadata, &smithy.SerializationError{Err: err} 1864 } 1865 in.Request = request 1866 1867 return next.HandleSerialize(ctx, in) 1868} 1869func awsRestjson1_serializeOpHttpBindingsRunPipelineActivityInput(v *RunPipelineActivityInput, encoder *httpbinding.Encoder) error { 1870 if v == nil { 1871 return fmt.Errorf("unsupported serialization of nil %T", v) 1872 } 1873 1874 return nil 1875} 1876 1877func awsRestjson1_serializeOpDocumentRunPipelineActivityInput(v *RunPipelineActivityInput, value smithyjson.Value) error { 1878 object := value.Object() 1879 defer object.Close() 1880 1881 if v.Payloads != nil { 1882 ok := object.Key("payloads") 1883 if err := awsRestjson1_serializeDocumentMessagePayloads(v.Payloads, ok); err != nil { 1884 return err 1885 } 1886 } 1887 1888 if v.PipelineActivity != nil { 1889 ok := object.Key("pipelineActivity") 1890 if err := awsRestjson1_serializeDocumentPipelineActivity(v.PipelineActivity, ok); err != nil { 1891 return err 1892 } 1893 } 1894 1895 return nil 1896} 1897 1898type awsRestjson1_serializeOpSampleChannelData struct { 1899} 1900 1901func (*awsRestjson1_serializeOpSampleChannelData) ID() string { 1902 return "OperationSerializer" 1903} 1904 1905func (m *awsRestjson1_serializeOpSampleChannelData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1906 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1907) { 1908 request, ok := in.Request.(*smithyhttp.Request) 1909 if !ok { 1910 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1911 } 1912 1913 input, ok := in.Parameters.(*SampleChannelDataInput) 1914 _ = input 1915 if !ok { 1916 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1917 } 1918 1919 opPath, opQuery := httpbinding.SplitURI("/channels/{channelName}/sample") 1920 request.URL.Path = opPath 1921 if len(request.URL.RawQuery) > 0 { 1922 request.URL.RawQuery = "&" + opQuery 1923 } else { 1924 request.URL.RawQuery = opQuery 1925 } 1926 1927 request.Method = "GET" 1928 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1929 if err != nil { 1930 return out, metadata, &smithy.SerializationError{Err: err} 1931 } 1932 1933 if err := awsRestjson1_serializeOpHttpBindingsSampleChannelDataInput(input, restEncoder); err != nil { 1934 return out, metadata, &smithy.SerializationError{Err: err} 1935 } 1936 1937 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1938 return out, metadata, &smithy.SerializationError{Err: err} 1939 } 1940 in.Request = request 1941 1942 return next.HandleSerialize(ctx, in) 1943} 1944func awsRestjson1_serializeOpHttpBindingsSampleChannelDataInput(v *SampleChannelDataInput, encoder *httpbinding.Encoder) error { 1945 if v == nil { 1946 return fmt.Errorf("unsupported serialization of nil %T", v) 1947 } 1948 1949 if v.ChannelName == nil || len(*v.ChannelName) == 0 { 1950 return &smithy.SerializationError{Err: fmt.Errorf("input member channelName must not be empty")} 1951 } 1952 if v.ChannelName != nil { 1953 if err := encoder.SetURI("channelName").String(*v.ChannelName); err != nil { 1954 return err 1955 } 1956 } 1957 1958 if v.EndTime != nil { 1959 encoder.SetQuery("endTime").String(smithytime.FormatDateTime(*v.EndTime)) 1960 } 1961 1962 if v.MaxMessages != nil { 1963 encoder.SetQuery("maxMessages").Integer(*v.MaxMessages) 1964 } 1965 1966 if v.StartTime != nil { 1967 encoder.SetQuery("startTime").String(smithytime.FormatDateTime(*v.StartTime)) 1968 } 1969 1970 return nil 1971} 1972 1973type awsRestjson1_serializeOpStartPipelineReprocessing struct { 1974} 1975 1976func (*awsRestjson1_serializeOpStartPipelineReprocessing) ID() string { 1977 return "OperationSerializer" 1978} 1979 1980func (m *awsRestjson1_serializeOpStartPipelineReprocessing) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1981 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1982) { 1983 request, ok := in.Request.(*smithyhttp.Request) 1984 if !ok { 1985 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1986 } 1987 1988 input, ok := in.Parameters.(*StartPipelineReprocessingInput) 1989 _ = input 1990 if !ok { 1991 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1992 } 1993 1994 opPath, opQuery := httpbinding.SplitURI("/pipelines/{pipelineName}/reprocessing") 1995 request.URL.Path = opPath 1996 if len(request.URL.RawQuery) > 0 { 1997 request.URL.RawQuery = "&" + opQuery 1998 } else { 1999 request.URL.RawQuery = opQuery 2000 } 2001 2002 request.Method = "POST" 2003 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2004 if err != nil { 2005 return out, metadata, &smithy.SerializationError{Err: err} 2006 } 2007 2008 if err := awsRestjson1_serializeOpHttpBindingsStartPipelineReprocessingInput(input, restEncoder); err != nil { 2009 return out, metadata, &smithy.SerializationError{Err: err} 2010 } 2011 2012 restEncoder.SetHeader("Content-Type").String("application/json") 2013 2014 jsonEncoder := smithyjson.NewEncoder() 2015 if err := awsRestjson1_serializeOpDocumentStartPipelineReprocessingInput(input, jsonEncoder.Value); err != nil { 2016 return out, metadata, &smithy.SerializationError{Err: err} 2017 } 2018 2019 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2020 return out, metadata, &smithy.SerializationError{Err: err} 2021 } 2022 2023 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2024 return out, metadata, &smithy.SerializationError{Err: err} 2025 } 2026 in.Request = request 2027 2028 return next.HandleSerialize(ctx, in) 2029} 2030func awsRestjson1_serializeOpHttpBindingsStartPipelineReprocessingInput(v *StartPipelineReprocessingInput, encoder *httpbinding.Encoder) error { 2031 if v == nil { 2032 return fmt.Errorf("unsupported serialization of nil %T", v) 2033 } 2034 2035 if v.PipelineName == nil || len(*v.PipelineName) == 0 { 2036 return &smithy.SerializationError{Err: fmt.Errorf("input member pipelineName must not be empty")} 2037 } 2038 if v.PipelineName != nil { 2039 if err := encoder.SetURI("pipelineName").String(*v.PipelineName); err != nil { 2040 return err 2041 } 2042 } 2043 2044 return nil 2045} 2046 2047func awsRestjson1_serializeOpDocumentStartPipelineReprocessingInput(v *StartPipelineReprocessingInput, value smithyjson.Value) error { 2048 object := value.Object() 2049 defer object.Close() 2050 2051 if v.ChannelMessages != nil { 2052 ok := object.Key("channelMessages") 2053 if err := awsRestjson1_serializeDocumentChannelMessages(v.ChannelMessages, ok); err != nil { 2054 return err 2055 } 2056 } 2057 2058 if v.EndTime != nil { 2059 ok := object.Key("endTime") 2060 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime)) 2061 } 2062 2063 if v.StartTime != nil { 2064 ok := object.Key("startTime") 2065 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime)) 2066 } 2067 2068 return nil 2069} 2070 2071type awsRestjson1_serializeOpTagResource struct { 2072} 2073 2074func (*awsRestjson1_serializeOpTagResource) ID() string { 2075 return "OperationSerializer" 2076} 2077 2078func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2079 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2080) { 2081 request, ok := in.Request.(*smithyhttp.Request) 2082 if !ok { 2083 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2084 } 2085 2086 input, ok := in.Parameters.(*TagResourceInput) 2087 _ = input 2088 if !ok { 2089 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2090 } 2091 2092 opPath, opQuery := httpbinding.SplitURI("/tags") 2093 request.URL.Path = opPath 2094 if len(request.URL.RawQuery) > 0 { 2095 request.URL.RawQuery = "&" + opQuery 2096 } else { 2097 request.URL.RawQuery = opQuery 2098 } 2099 2100 request.Method = "POST" 2101 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2102 if err != nil { 2103 return out, metadata, &smithy.SerializationError{Err: err} 2104 } 2105 2106 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 2107 return out, metadata, &smithy.SerializationError{Err: err} 2108 } 2109 2110 restEncoder.SetHeader("Content-Type").String("application/json") 2111 2112 jsonEncoder := smithyjson.NewEncoder() 2113 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 2114 return out, metadata, &smithy.SerializationError{Err: err} 2115 } 2116 2117 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2118 return out, metadata, &smithy.SerializationError{Err: err} 2119 } 2120 2121 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2122 return out, metadata, &smithy.SerializationError{Err: err} 2123 } 2124 in.Request = request 2125 2126 return next.HandleSerialize(ctx, in) 2127} 2128func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 2129 if v == nil { 2130 return fmt.Errorf("unsupported serialization of nil %T", v) 2131 } 2132 2133 if v.ResourceArn != nil { 2134 encoder.SetQuery("resourceArn").String(*v.ResourceArn) 2135 } 2136 2137 return nil 2138} 2139 2140func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 2141 object := value.Object() 2142 defer object.Close() 2143 2144 if v.Tags != nil { 2145 ok := object.Key("tags") 2146 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 2147 return err 2148 } 2149 } 2150 2151 return nil 2152} 2153 2154type awsRestjson1_serializeOpUntagResource struct { 2155} 2156 2157func (*awsRestjson1_serializeOpUntagResource) ID() string { 2158 return "OperationSerializer" 2159} 2160 2161func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2162 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2163) { 2164 request, ok := in.Request.(*smithyhttp.Request) 2165 if !ok { 2166 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2167 } 2168 2169 input, ok := in.Parameters.(*UntagResourceInput) 2170 _ = input 2171 if !ok { 2172 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2173 } 2174 2175 opPath, opQuery := httpbinding.SplitURI("/tags") 2176 request.URL.Path = opPath 2177 if len(request.URL.RawQuery) > 0 { 2178 request.URL.RawQuery = "&" + opQuery 2179 } else { 2180 request.URL.RawQuery = opQuery 2181 } 2182 2183 request.Method = "DELETE" 2184 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2185 if err != nil { 2186 return out, metadata, &smithy.SerializationError{Err: err} 2187 } 2188 2189 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 2190 return out, metadata, &smithy.SerializationError{Err: err} 2191 } 2192 2193 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2194 return out, metadata, &smithy.SerializationError{Err: err} 2195 } 2196 in.Request = request 2197 2198 return next.HandleSerialize(ctx, in) 2199} 2200func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 2201 if v == nil { 2202 return fmt.Errorf("unsupported serialization of nil %T", v) 2203 } 2204 2205 if v.ResourceArn != nil { 2206 encoder.SetQuery("resourceArn").String(*v.ResourceArn) 2207 } 2208 2209 if v.TagKeys != nil { 2210 for i := range v.TagKeys { 2211 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 2212 } 2213 } 2214 2215 return nil 2216} 2217 2218type awsRestjson1_serializeOpUpdateChannel struct { 2219} 2220 2221func (*awsRestjson1_serializeOpUpdateChannel) ID() string { 2222 return "OperationSerializer" 2223} 2224 2225func (m *awsRestjson1_serializeOpUpdateChannel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2226 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2227) { 2228 request, ok := in.Request.(*smithyhttp.Request) 2229 if !ok { 2230 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2231 } 2232 2233 input, ok := in.Parameters.(*UpdateChannelInput) 2234 _ = input 2235 if !ok { 2236 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2237 } 2238 2239 opPath, opQuery := httpbinding.SplitURI("/channels/{channelName}") 2240 request.URL.Path = opPath 2241 if len(request.URL.RawQuery) > 0 { 2242 request.URL.RawQuery = "&" + opQuery 2243 } else { 2244 request.URL.RawQuery = opQuery 2245 } 2246 2247 request.Method = "PUT" 2248 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2249 if err != nil { 2250 return out, metadata, &smithy.SerializationError{Err: err} 2251 } 2252 2253 if err := awsRestjson1_serializeOpHttpBindingsUpdateChannelInput(input, restEncoder); err != nil { 2254 return out, metadata, &smithy.SerializationError{Err: err} 2255 } 2256 2257 restEncoder.SetHeader("Content-Type").String("application/json") 2258 2259 jsonEncoder := smithyjson.NewEncoder() 2260 if err := awsRestjson1_serializeOpDocumentUpdateChannelInput(input, jsonEncoder.Value); err != nil { 2261 return out, metadata, &smithy.SerializationError{Err: err} 2262 } 2263 2264 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2265 return out, metadata, &smithy.SerializationError{Err: err} 2266 } 2267 2268 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2269 return out, metadata, &smithy.SerializationError{Err: err} 2270 } 2271 in.Request = request 2272 2273 return next.HandleSerialize(ctx, in) 2274} 2275func awsRestjson1_serializeOpHttpBindingsUpdateChannelInput(v *UpdateChannelInput, encoder *httpbinding.Encoder) error { 2276 if v == nil { 2277 return fmt.Errorf("unsupported serialization of nil %T", v) 2278 } 2279 2280 if v.ChannelName == nil || len(*v.ChannelName) == 0 { 2281 return &smithy.SerializationError{Err: fmt.Errorf("input member channelName must not be empty")} 2282 } 2283 if v.ChannelName != nil { 2284 if err := encoder.SetURI("channelName").String(*v.ChannelName); err != nil { 2285 return err 2286 } 2287 } 2288 2289 return nil 2290} 2291 2292func awsRestjson1_serializeOpDocumentUpdateChannelInput(v *UpdateChannelInput, value smithyjson.Value) error { 2293 object := value.Object() 2294 defer object.Close() 2295 2296 if v.ChannelStorage != nil { 2297 ok := object.Key("channelStorage") 2298 if err := awsRestjson1_serializeDocumentChannelStorage(v.ChannelStorage, ok); err != nil { 2299 return err 2300 } 2301 } 2302 2303 if v.RetentionPeriod != nil { 2304 ok := object.Key("retentionPeriod") 2305 if err := awsRestjson1_serializeDocumentRetentionPeriod(v.RetentionPeriod, ok); err != nil { 2306 return err 2307 } 2308 } 2309 2310 return nil 2311} 2312 2313type awsRestjson1_serializeOpUpdateDataset struct { 2314} 2315 2316func (*awsRestjson1_serializeOpUpdateDataset) ID() string { 2317 return "OperationSerializer" 2318} 2319 2320func (m *awsRestjson1_serializeOpUpdateDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2321 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2322) { 2323 request, ok := in.Request.(*smithyhttp.Request) 2324 if !ok { 2325 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2326 } 2327 2328 input, ok := in.Parameters.(*UpdateDatasetInput) 2329 _ = input 2330 if !ok { 2331 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2332 } 2333 2334 opPath, opQuery := httpbinding.SplitURI("/datasets/{datasetName}") 2335 request.URL.Path = opPath 2336 if len(request.URL.RawQuery) > 0 { 2337 request.URL.RawQuery = "&" + opQuery 2338 } else { 2339 request.URL.RawQuery = opQuery 2340 } 2341 2342 request.Method = "PUT" 2343 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2344 if err != nil { 2345 return out, metadata, &smithy.SerializationError{Err: err} 2346 } 2347 2348 if err := awsRestjson1_serializeOpHttpBindingsUpdateDatasetInput(input, restEncoder); err != nil { 2349 return out, metadata, &smithy.SerializationError{Err: err} 2350 } 2351 2352 restEncoder.SetHeader("Content-Type").String("application/json") 2353 2354 jsonEncoder := smithyjson.NewEncoder() 2355 if err := awsRestjson1_serializeOpDocumentUpdateDatasetInput(input, jsonEncoder.Value); err != nil { 2356 return out, metadata, &smithy.SerializationError{Err: err} 2357 } 2358 2359 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2360 return out, metadata, &smithy.SerializationError{Err: err} 2361 } 2362 2363 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2364 return out, metadata, &smithy.SerializationError{Err: err} 2365 } 2366 in.Request = request 2367 2368 return next.HandleSerialize(ctx, in) 2369} 2370func awsRestjson1_serializeOpHttpBindingsUpdateDatasetInput(v *UpdateDatasetInput, encoder *httpbinding.Encoder) error { 2371 if v == nil { 2372 return fmt.Errorf("unsupported serialization of nil %T", v) 2373 } 2374 2375 if v.DatasetName == nil || len(*v.DatasetName) == 0 { 2376 return &smithy.SerializationError{Err: fmt.Errorf("input member datasetName must not be empty")} 2377 } 2378 if v.DatasetName != nil { 2379 if err := encoder.SetURI("datasetName").String(*v.DatasetName); err != nil { 2380 return err 2381 } 2382 } 2383 2384 return nil 2385} 2386 2387func awsRestjson1_serializeOpDocumentUpdateDatasetInput(v *UpdateDatasetInput, value smithyjson.Value) error { 2388 object := value.Object() 2389 defer object.Close() 2390 2391 if v.Actions != nil { 2392 ok := object.Key("actions") 2393 if err := awsRestjson1_serializeDocumentDatasetActions(v.Actions, ok); err != nil { 2394 return err 2395 } 2396 } 2397 2398 if v.ContentDeliveryRules != nil { 2399 ok := object.Key("contentDeliveryRules") 2400 if err := awsRestjson1_serializeDocumentDatasetContentDeliveryRules(v.ContentDeliveryRules, ok); err != nil { 2401 return err 2402 } 2403 } 2404 2405 if v.LateDataRules != nil { 2406 ok := object.Key("lateDataRules") 2407 if err := awsRestjson1_serializeDocumentLateDataRules(v.LateDataRules, ok); err != nil { 2408 return err 2409 } 2410 } 2411 2412 if v.RetentionPeriod != nil { 2413 ok := object.Key("retentionPeriod") 2414 if err := awsRestjson1_serializeDocumentRetentionPeriod(v.RetentionPeriod, ok); err != nil { 2415 return err 2416 } 2417 } 2418 2419 if v.Triggers != nil { 2420 ok := object.Key("triggers") 2421 if err := awsRestjson1_serializeDocumentDatasetTriggers(v.Triggers, ok); err != nil { 2422 return err 2423 } 2424 } 2425 2426 if v.VersioningConfiguration != nil { 2427 ok := object.Key("versioningConfiguration") 2428 if err := awsRestjson1_serializeDocumentVersioningConfiguration(v.VersioningConfiguration, ok); err != nil { 2429 return err 2430 } 2431 } 2432 2433 return nil 2434} 2435 2436type awsRestjson1_serializeOpUpdateDatastore struct { 2437} 2438 2439func (*awsRestjson1_serializeOpUpdateDatastore) ID() string { 2440 return "OperationSerializer" 2441} 2442 2443func (m *awsRestjson1_serializeOpUpdateDatastore) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2444 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2445) { 2446 request, ok := in.Request.(*smithyhttp.Request) 2447 if !ok { 2448 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2449 } 2450 2451 input, ok := in.Parameters.(*UpdateDatastoreInput) 2452 _ = input 2453 if !ok { 2454 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2455 } 2456 2457 opPath, opQuery := httpbinding.SplitURI("/datastores/{datastoreName}") 2458 request.URL.Path = opPath 2459 if len(request.URL.RawQuery) > 0 { 2460 request.URL.RawQuery = "&" + opQuery 2461 } else { 2462 request.URL.RawQuery = opQuery 2463 } 2464 2465 request.Method = "PUT" 2466 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2467 if err != nil { 2468 return out, metadata, &smithy.SerializationError{Err: err} 2469 } 2470 2471 if err := awsRestjson1_serializeOpHttpBindingsUpdateDatastoreInput(input, restEncoder); err != nil { 2472 return out, metadata, &smithy.SerializationError{Err: err} 2473 } 2474 2475 restEncoder.SetHeader("Content-Type").String("application/json") 2476 2477 jsonEncoder := smithyjson.NewEncoder() 2478 if err := awsRestjson1_serializeOpDocumentUpdateDatastoreInput(input, jsonEncoder.Value); err != nil { 2479 return out, metadata, &smithy.SerializationError{Err: err} 2480 } 2481 2482 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2483 return out, metadata, &smithy.SerializationError{Err: err} 2484 } 2485 2486 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2487 return out, metadata, &smithy.SerializationError{Err: err} 2488 } 2489 in.Request = request 2490 2491 return next.HandleSerialize(ctx, in) 2492} 2493func awsRestjson1_serializeOpHttpBindingsUpdateDatastoreInput(v *UpdateDatastoreInput, encoder *httpbinding.Encoder) error { 2494 if v == nil { 2495 return fmt.Errorf("unsupported serialization of nil %T", v) 2496 } 2497 2498 if v.DatastoreName == nil || len(*v.DatastoreName) == 0 { 2499 return &smithy.SerializationError{Err: fmt.Errorf("input member datastoreName must not be empty")} 2500 } 2501 if v.DatastoreName != nil { 2502 if err := encoder.SetURI("datastoreName").String(*v.DatastoreName); err != nil { 2503 return err 2504 } 2505 } 2506 2507 return nil 2508} 2509 2510func awsRestjson1_serializeOpDocumentUpdateDatastoreInput(v *UpdateDatastoreInput, value smithyjson.Value) error { 2511 object := value.Object() 2512 defer object.Close() 2513 2514 if v.DatastoreStorage != nil { 2515 ok := object.Key("datastoreStorage") 2516 if err := awsRestjson1_serializeDocumentDatastoreStorage(v.DatastoreStorage, ok); err != nil { 2517 return err 2518 } 2519 } 2520 2521 if v.FileFormatConfiguration != nil { 2522 ok := object.Key("fileFormatConfiguration") 2523 if err := awsRestjson1_serializeDocumentFileFormatConfiguration(v.FileFormatConfiguration, ok); err != nil { 2524 return err 2525 } 2526 } 2527 2528 if v.RetentionPeriod != nil { 2529 ok := object.Key("retentionPeriod") 2530 if err := awsRestjson1_serializeDocumentRetentionPeriod(v.RetentionPeriod, ok); err != nil { 2531 return err 2532 } 2533 } 2534 2535 return nil 2536} 2537 2538type awsRestjson1_serializeOpUpdatePipeline struct { 2539} 2540 2541func (*awsRestjson1_serializeOpUpdatePipeline) ID() string { 2542 return "OperationSerializer" 2543} 2544 2545func (m *awsRestjson1_serializeOpUpdatePipeline) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2546 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2547) { 2548 request, ok := in.Request.(*smithyhttp.Request) 2549 if !ok { 2550 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2551 } 2552 2553 input, ok := in.Parameters.(*UpdatePipelineInput) 2554 _ = input 2555 if !ok { 2556 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2557 } 2558 2559 opPath, opQuery := httpbinding.SplitURI("/pipelines/{pipelineName}") 2560 request.URL.Path = opPath 2561 if len(request.URL.RawQuery) > 0 { 2562 request.URL.RawQuery = "&" + opQuery 2563 } else { 2564 request.URL.RawQuery = opQuery 2565 } 2566 2567 request.Method = "PUT" 2568 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2569 if err != nil { 2570 return out, metadata, &smithy.SerializationError{Err: err} 2571 } 2572 2573 if err := awsRestjson1_serializeOpHttpBindingsUpdatePipelineInput(input, restEncoder); err != nil { 2574 return out, metadata, &smithy.SerializationError{Err: err} 2575 } 2576 2577 restEncoder.SetHeader("Content-Type").String("application/json") 2578 2579 jsonEncoder := smithyjson.NewEncoder() 2580 if err := awsRestjson1_serializeOpDocumentUpdatePipelineInput(input, jsonEncoder.Value); err != nil { 2581 return out, metadata, &smithy.SerializationError{Err: err} 2582 } 2583 2584 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2585 return out, metadata, &smithy.SerializationError{Err: err} 2586 } 2587 2588 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2589 return out, metadata, &smithy.SerializationError{Err: err} 2590 } 2591 in.Request = request 2592 2593 return next.HandleSerialize(ctx, in) 2594} 2595func awsRestjson1_serializeOpHttpBindingsUpdatePipelineInput(v *UpdatePipelineInput, encoder *httpbinding.Encoder) error { 2596 if v == nil { 2597 return fmt.Errorf("unsupported serialization of nil %T", v) 2598 } 2599 2600 if v.PipelineName == nil || len(*v.PipelineName) == 0 { 2601 return &smithy.SerializationError{Err: fmt.Errorf("input member pipelineName must not be empty")} 2602 } 2603 if v.PipelineName != nil { 2604 if err := encoder.SetURI("pipelineName").String(*v.PipelineName); err != nil { 2605 return err 2606 } 2607 } 2608 2609 return nil 2610} 2611 2612func awsRestjson1_serializeOpDocumentUpdatePipelineInput(v *UpdatePipelineInput, value smithyjson.Value) error { 2613 object := value.Object() 2614 defer object.Close() 2615 2616 if v.PipelineActivities != nil { 2617 ok := object.Key("pipelineActivities") 2618 if err := awsRestjson1_serializeDocumentPipelineActivities(v.PipelineActivities, ok); err != nil { 2619 return err 2620 } 2621 } 2622 2623 return nil 2624} 2625 2626func awsRestjson1_serializeDocumentAddAttributesActivity(v *types.AddAttributesActivity, value smithyjson.Value) error { 2627 object := value.Object() 2628 defer object.Close() 2629 2630 if v.Attributes != nil { 2631 ok := object.Key("attributes") 2632 if err := awsRestjson1_serializeDocumentAttributeNameMapping(v.Attributes, ok); err != nil { 2633 return err 2634 } 2635 } 2636 2637 if v.Name != nil { 2638 ok := object.Key("name") 2639 ok.String(*v.Name) 2640 } 2641 2642 if v.Next != nil { 2643 ok := object.Key("next") 2644 ok.String(*v.Next) 2645 } 2646 2647 return nil 2648} 2649 2650func awsRestjson1_serializeDocumentAttributeNameMapping(v map[string]string, value smithyjson.Value) error { 2651 object := value.Object() 2652 defer object.Close() 2653 2654 for key := range v { 2655 om := object.Key(key) 2656 om.String(v[key]) 2657 } 2658 return nil 2659} 2660 2661func awsRestjson1_serializeDocumentAttributeNames(v []string, value smithyjson.Value) error { 2662 array := value.Array() 2663 defer array.Close() 2664 2665 for i := range v { 2666 av := array.Value() 2667 av.String(v[i]) 2668 } 2669 return nil 2670} 2671 2672func awsRestjson1_serializeDocumentChannelActivity(v *types.ChannelActivity, value smithyjson.Value) error { 2673 object := value.Object() 2674 defer object.Close() 2675 2676 if v.ChannelName != nil { 2677 ok := object.Key("channelName") 2678 ok.String(*v.ChannelName) 2679 } 2680 2681 if v.Name != nil { 2682 ok := object.Key("name") 2683 ok.String(*v.Name) 2684 } 2685 2686 if v.Next != nil { 2687 ok := object.Key("next") 2688 ok.String(*v.Next) 2689 } 2690 2691 return nil 2692} 2693 2694func awsRestjson1_serializeDocumentChannelMessages(v *types.ChannelMessages, value smithyjson.Value) error { 2695 object := value.Object() 2696 defer object.Close() 2697 2698 if v.S3Paths != nil { 2699 ok := object.Key("s3Paths") 2700 if err := awsRestjson1_serializeDocumentS3PathChannelMessages(v.S3Paths, ok); err != nil { 2701 return err 2702 } 2703 } 2704 2705 return nil 2706} 2707 2708func awsRestjson1_serializeDocumentChannelStorage(v *types.ChannelStorage, value smithyjson.Value) error { 2709 object := value.Object() 2710 defer object.Close() 2711 2712 if v.CustomerManagedS3 != nil { 2713 ok := object.Key("customerManagedS3") 2714 if err := awsRestjson1_serializeDocumentCustomerManagedChannelS3Storage(v.CustomerManagedS3, ok); err != nil { 2715 return err 2716 } 2717 } 2718 2719 if v.ServiceManagedS3 != nil { 2720 ok := object.Key("serviceManagedS3") 2721 if err := awsRestjson1_serializeDocumentServiceManagedChannelS3Storage(v.ServiceManagedS3, ok); err != nil { 2722 return err 2723 } 2724 } 2725 2726 return nil 2727} 2728 2729func awsRestjson1_serializeDocumentColumn(v *types.Column, value smithyjson.Value) error { 2730 object := value.Object() 2731 defer object.Close() 2732 2733 if v.Name != nil { 2734 ok := object.Key("name") 2735 ok.String(*v.Name) 2736 } 2737 2738 if v.Type != nil { 2739 ok := object.Key("type") 2740 ok.String(*v.Type) 2741 } 2742 2743 return nil 2744} 2745 2746func awsRestjson1_serializeDocumentColumns(v []types.Column, value smithyjson.Value) error { 2747 array := value.Array() 2748 defer array.Close() 2749 2750 for i := range v { 2751 av := array.Value() 2752 if err := awsRestjson1_serializeDocumentColumn(&v[i], av); err != nil { 2753 return err 2754 } 2755 } 2756 return nil 2757} 2758 2759func awsRestjson1_serializeDocumentContainerDatasetAction(v *types.ContainerDatasetAction, value smithyjson.Value) error { 2760 object := value.Object() 2761 defer object.Close() 2762 2763 if v.ExecutionRoleArn != nil { 2764 ok := object.Key("executionRoleArn") 2765 ok.String(*v.ExecutionRoleArn) 2766 } 2767 2768 if v.Image != nil { 2769 ok := object.Key("image") 2770 ok.String(*v.Image) 2771 } 2772 2773 if v.ResourceConfiguration != nil { 2774 ok := object.Key("resourceConfiguration") 2775 if err := awsRestjson1_serializeDocumentResourceConfiguration(v.ResourceConfiguration, ok); err != nil { 2776 return err 2777 } 2778 } 2779 2780 if v.Variables != nil { 2781 ok := object.Key("variables") 2782 if err := awsRestjson1_serializeDocumentVariables(v.Variables, ok); err != nil { 2783 return err 2784 } 2785 } 2786 2787 return nil 2788} 2789 2790func awsRestjson1_serializeDocumentCustomerManagedChannelS3Storage(v *types.CustomerManagedChannelS3Storage, value smithyjson.Value) error { 2791 object := value.Object() 2792 defer object.Close() 2793 2794 if v.Bucket != nil { 2795 ok := object.Key("bucket") 2796 ok.String(*v.Bucket) 2797 } 2798 2799 if v.KeyPrefix != nil { 2800 ok := object.Key("keyPrefix") 2801 ok.String(*v.KeyPrefix) 2802 } 2803 2804 if v.RoleArn != nil { 2805 ok := object.Key("roleArn") 2806 ok.String(*v.RoleArn) 2807 } 2808 2809 return nil 2810} 2811 2812func awsRestjson1_serializeDocumentCustomerManagedDatastoreS3Storage(v *types.CustomerManagedDatastoreS3Storage, value smithyjson.Value) error { 2813 object := value.Object() 2814 defer object.Close() 2815 2816 if v.Bucket != nil { 2817 ok := object.Key("bucket") 2818 ok.String(*v.Bucket) 2819 } 2820 2821 if v.KeyPrefix != nil { 2822 ok := object.Key("keyPrefix") 2823 ok.String(*v.KeyPrefix) 2824 } 2825 2826 if v.RoleArn != nil { 2827 ok := object.Key("roleArn") 2828 ok.String(*v.RoleArn) 2829 } 2830 2831 return nil 2832} 2833 2834func awsRestjson1_serializeDocumentDatasetAction(v *types.DatasetAction, value smithyjson.Value) error { 2835 object := value.Object() 2836 defer object.Close() 2837 2838 if v.ActionName != nil { 2839 ok := object.Key("actionName") 2840 ok.String(*v.ActionName) 2841 } 2842 2843 if v.ContainerAction != nil { 2844 ok := object.Key("containerAction") 2845 if err := awsRestjson1_serializeDocumentContainerDatasetAction(v.ContainerAction, ok); err != nil { 2846 return err 2847 } 2848 } 2849 2850 if v.QueryAction != nil { 2851 ok := object.Key("queryAction") 2852 if err := awsRestjson1_serializeDocumentSqlQueryDatasetAction(v.QueryAction, ok); err != nil { 2853 return err 2854 } 2855 } 2856 2857 return nil 2858} 2859 2860func awsRestjson1_serializeDocumentDatasetActions(v []types.DatasetAction, value smithyjson.Value) error { 2861 array := value.Array() 2862 defer array.Close() 2863 2864 for i := range v { 2865 av := array.Value() 2866 if err := awsRestjson1_serializeDocumentDatasetAction(&v[i], av); err != nil { 2867 return err 2868 } 2869 } 2870 return nil 2871} 2872 2873func awsRestjson1_serializeDocumentDatasetContentDeliveryDestination(v *types.DatasetContentDeliveryDestination, value smithyjson.Value) error { 2874 object := value.Object() 2875 defer object.Close() 2876 2877 if v.IotEventsDestinationConfiguration != nil { 2878 ok := object.Key("iotEventsDestinationConfiguration") 2879 if err := awsRestjson1_serializeDocumentIotEventsDestinationConfiguration(v.IotEventsDestinationConfiguration, ok); err != nil { 2880 return err 2881 } 2882 } 2883 2884 if v.S3DestinationConfiguration != nil { 2885 ok := object.Key("s3DestinationConfiguration") 2886 if err := awsRestjson1_serializeDocumentS3DestinationConfiguration(v.S3DestinationConfiguration, ok); err != nil { 2887 return err 2888 } 2889 } 2890 2891 return nil 2892} 2893 2894func awsRestjson1_serializeDocumentDatasetContentDeliveryRule(v *types.DatasetContentDeliveryRule, value smithyjson.Value) error { 2895 object := value.Object() 2896 defer object.Close() 2897 2898 if v.Destination != nil { 2899 ok := object.Key("destination") 2900 if err := awsRestjson1_serializeDocumentDatasetContentDeliveryDestination(v.Destination, ok); err != nil { 2901 return err 2902 } 2903 } 2904 2905 if v.EntryName != nil { 2906 ok := object.Key("entryName") 2907 ok.String(*v.EntryName) 2908 } 2909 2910 return nil 2911} 2912 2913func awsRestjson1_serializeDocumentDatasetContentDeliveryRules(v []types.DatasetContentDeliveryRule, value smithyjson.Value) error { 2914 array := value.Array() 2915 defer array.Close() 2916 2917 for i := range v { 2918 av := array.Value() 2919 if err := awsRestjson1_serializeDocumentDatasetContentDeliveryRule(&v[i], av); err != nil { 2920 return err 2921 } 2922 } 2923 return nil 2924} 2925 2926func awsRestjson1_serializeDocumentDatasetContentVersionValue(v *types.DatasetContentVersionValue, value smithyjson.Value) error { 2927 object := value.Object() 2928 defer object.Close() 2929 2930 if v.DatasetName != nil { 2931 ok := object.Key("datasetName") 2932 ok.String(*v.DatasetName) 2933 } 2934 2935 return nil 2936} 2937 2938func awsRestjson1_serializeDocumentDatasetTrigger(v *types.DatasetTrigger, value smithyjson.Value) error { 2939 object := value.Object() 2940 defer object.Close() 2941 2942 if v.Dataset != nil { 2943 ok := object.Key("dataset") 2944 if err := awsRestjson1_serializeDocumentTriggeringDataset(v.Dataset, ok); err != nil { 2945 return err 2946 } 2947 } 2948 2949 if v.Schedule != nil { 2950 ok := object.Key("schedule") 2951 if err := awsRestjson1_serializeDocumentSchedule(v.Schedule, ok); err != nil { 2952 return err 2953 } 2954 } 2955 2956 return nil 2957} 2958 2959func awsRestjson1_serializeDocumentDatasetTriggers(v []types.DatasetTrigger, value smithyjson.Value) error { 2960 array := value.Array() 2961 defer array.Close() 2962 2963 for i := range v { 2964 av := array.Value() 2965 if err := awsRestjson1_serializeDocumentDatasetTrigger(&v[i], av); err != nil { 2966 return err 2967 } 2968 } 2969 return nil 2970} 2971 2972func awsRestjson1_serializeDocumentDatastoreActivity(v *types.DatastoreActivity, value smithyjson.Value) error { 2973 object := value.Object() 2974 defer object.Close() 2975 2976 if v.DatastoreName != nil { 2977 ok := object.Key("datastoreName") 2978 ok.String(*v.DatastoreName) 2979 } 2980 2981 if v.Name != nil { 2982 ok := object.Key("name") 2983 ok.String(*v.Name) 2984 } 2985 2986 return nil 2987} 2988 2989func awsRestjson1_serializeDocumentDatastoreStorage(v types.DatastoreStorage, value smithyjson.Value) error { 2990 object := value.Object() 2991 defer object.Close() 2992 2993 switch uv := v.(type) { 2994 case *types.DatastoreStorageMemberCustomerManagedS3: 2995 av := object.Key("customerManagedS3") 2996 if err := awsRestjson1_serializeDocumentCustomerManagedDatastoreS3Storage(&uv.Value, av); err != nil { 2997 return err 2998 } 2999 3000 case *types.DatastoreStorageMemberServiceManagedS3: 3001 av := object.Key("serviceManagedS3") 3002 if err := awsRestjson1_serializeDocumentServiceManagedDatastoreS3Storage(&uv.Value, av); err != nil { 3003 return err 3004 } 3005 3006 default: 3007 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 3008 3009 } 3010 return nil 3011} 3012 3013func awsRestjson1_serializeDocumentDeltaTime(v *types.DeltaTime, value smithyjson.Value) error { 3014 object := value.Object() 3015 defer object.Close() 3016 3017 if v.OffsetSeconds != nil { 3018 ok := object.Key("offsetSeconds") 3019 ok.Integer(*v.OffsetSeconds) 3020 } 3021 3022 if v.TimeExpression != nil { 3023 ok := object.Key("timeExpression") 3024 ok.String(*v.TimeExpression) 3025 } 3026 3027 return nil 3028} 3029 3030func awsRestjson1_serializeDocumentDeltaTimeSessionWindowConfiguration(v *types.DeltaTimeSessionWindowConfiguration, value smithyjson.Value) error { 3031 object := value.Object() 3032 defer object.Close() 3033 3034 if v.TimeoutInMinutes != nil { 3035 ok := object.Key("timeoutInMinutes") 3036 ok.Integer(*v.TimeoutInMinutes) 3037 } 3038 3039 return nil 3040} 3041 3042func awsRestjson1_serializeDocumentDeviceRegistryEnrichActivity(v *types.DeviceRegistryEnrichActivity, value smithyjson.Value) error { 3043 object := value.Object() 3044 defer object.Close() 3045 3046 if v.Attribute != nil { 3047 ok := object.Key("attribute") 3048 ok.String(*v.Attribute) 3049 } 3050 3051 if v.Name != nil { 3052 ok := object.Key("name") 3053 ok.String(*v.Name) 3054 } 3055 3056 if v.Next != nil { 3057 ok := object.Key("next") 3058 ok.String(*v.Next) 3059 } 3060 3061 if v.RoleArn != nil { 3062 ok := object.Key("roleArn") 3063 ok.String(*v.RoleArn) 3064 } 3065 3066 if v.ThingName != nil { 3067 ok := object.Key("thingName") 3068 ok.String(*v.ThingName) 3069 } 3070 3071 return nil 3072} 3073 3074func awsRestjson1_serializeDocumentDeviceShadowEnrichActivity(v *types.DeviceShadowEnrichActivity, value smithyjson.Value) error { 3075 object := value.Object() 3076 defer object.Close() 3077 3078 if v.Attribute != nil { 3079 ok := object.Key("attribute") 3080 ok.String(*v.Attribute) 3081 } 3082 3083 if v.Name != nil { 3084 ok := object.Key("name") 3085 ok.String(*v.Name) 3086 } 3087 3088 if v.Next != nil { 3089 ok := object.Key("next") 3090 ok.String(*v.Next) 3091 } 3092 3093 if v.RoleArn != nil { 3094 ok := object.Key("roleArn") 3095 ok.String(*v.RoleArn) 3096 } 3097 3098 if v.ThingName != nil { 3099 ok := object.Key("thingName") 3100 ok.String(*v.ThingName) 3101 } 3102 3103 return nil 3104} 3105 3106func awsRestjson1_serializeDocumentFileFormatConfiguration(v *types.FileFormatConfiguration, value smithyjson.Value) error { 3107 object := value.Object() 3108 defer object.Close() 3109 3110 if v.JsonConfiguration != nil { 3111 ok := object.Key("jsonConfiguration") 3112 if err := awsRestjson1_serializeDocumentJsonConfiguration(v.JsonConfiguration, ok); err != nil { 3113 return err 3114 } 3115 } 3116 3117 if v.ParquetConfiguration != nil { 3118 ok := object.Key("parquetConfiguration") 3119 if err := awsRestjson1_serializeDocumentParquetConfiguration(v.ParquetConfiguration, ok); err != nil { 3120 return err 3121 } 3122 } 3123 3124 return nil 3125} 3126 3127func awsRestjson1_serializeDocumentFilterActivity(v *types.FilterActivity, value smithyjson.Value) error { 3128 object := value.Object() 3129 defer object.Close() 3130 3131 if v.Filter != nil { 3132 ok := object.Key("filter") 3133 ok.String(*v.Filter) 3134 } 3135 3136 if v.Name != nil { 3137 ok := object.Key("name") 3138 ok.String(*v.Name) 3139 } 3140 3141 if v.Next != nil { 3142 ok := object.Key("next") 3143 ok.String(*v.Next) 3144 } 3145 3146 return nil 3147} 3148 3149func awsRestjson1_serializeDocumentGlueConfiguration(v *types.GlueConfiguration, value smithyjson.Value) error { 3150 object := value.Object() 3151 defer object.Close() 3152 3153 if v.DatabaseName != nil { 3154 ok := object.Key("databaseName") 3155 ok.String(*v.DatabaseName) 3156 } 3157 3158 if v.TableName != nil { 3159 ok := object.Key("tableName") 3160 ok.String(*v.TableName) 3161 } 3162 3163 return nil 3164} 3165 3166func awsRestjson1_serializeDocumentIotEventsDestinationConfiguration(v *types.IotEventsDestinationConfiguration, value smithyjson.Value) error { 3167 object := value.Object() 3168 defer object.Close() 3169 3170 if v.InputName != nil { 3171 ok := object.Key("inputName") 3172 ok.String(*v.InputName) 3173 } 3174 3175 if v.RoleArn != nil { 3176 ok := object.Key("roleArn") 3177 ok.String(*v.RoleArn) 3178 } 3179 3180 return nil 3181} 3182 3183func awsRestjson1_serializeDocumentJsonConfiguration(v *types.JsonConfiguration, value smithyjson.Value) error { 3184 object := value.Object() 3185 defer object.Close() 3186 3187 return nil 3188} 3189 3190func awsRestjson1_serializeDocumentLambdaActivity(v *types.LambdaActivity, value smithyjson.Value) error { 3191 object := value.Object() 3192 defer object.Close() 3193 3194 if v.BatchSize != nil { 3195 ok := object.Key("batchSize") 3196 ok.Integer(*v.BatchSize) 3197 } 3198 3199 if v.LambdaName != nil { 3200 ok := object.Key("lambdaName") 3201 ok.String(*v.LambdaName) 3202 } 3203 3204 if v.Name != nil { 3205 ok := object.Key("name") 3206 ok.String(*v.Name) 3207 } 3208 3209 if v.Next != nil { 3210 ok := object.Key("next") 3211 ok.String(*v.Next) 3212 } 3213 3214 return nil 3215} 3216 3217func awsRestjson1_serializeDocumentLateDataRule(v *types.LateDataRule, value smithyjson.Value) error { 3218 object := value.Object() 3219 defer object.Close() 3220 3221 if v.RuleConfiguration != nil { 3222 ok := object.Key("ruleConfiguration") 3223 if err := awsRestjson1_serializeDocumentLateDataRuleConfiguration(v.RuleConfiguration, ok); err != nil { 3224 return err 3225 } 3226 } 3227 3228 if v.RuleName != nil { 3229 ok := object.Key("ruleName") 3230 ok.String(*v.RuleName) 3231 } 3232 3233 return nil 3234} 3235 3236func awsRestjson1_serializeDocumentLateDataRuleConfiguration(v *types.LateDataRuleConfiguration, value smithyjson.Value) error { 3237 object := value.Object() 3238 defer object.Close() 3239 3240 if v.DeltaTimeSessionWindowConfiguration != nil { 3241 ok := object.Key("deltaTimeSessionWindowConfiguration") 3242 if err := awsRestjson1_serializeDocumentDeltaTimeSessionWindowConfiguration(v.DeltaTimeSessionWindowConfiguration, ok); err != nil { 3243 return err 3244 } 3245 } 3246 3247 return nil 3248} 3249 3250func awsRestjson1_serializeDocumentLateDataRules(v []types.LateDataRule, value smithyjson.Value) error { 3251 array := value.Array() 3252 defer array.Close() 3253 3254 for i := range v { 3255 av := array.Value() 3256 if err := awsRestjson1_serializeDocumentLateDataRule(&v[i], av); err != nil { 3257 return err 3258 } 3259 } 3260 return nil 3261} 3262 3263func awsRestjson1_serializeDocumentLoggingOptions(v *types.LoggingOptions, value smithyjson.Value) error { 3264 object := value.Object() 3265 defer object.Close() 3266 3267 if v.Enabled { 3268 ok := object.Key("enabled") 3269 ok.Boolean(v.Enabled) 3270 } 3271 3272 if len(v.Level) > 0 { 3273 ok := object.Key("level") 3274 ok.String(string(v.Level)) 3275 } 3276 3277 if v.RoleArn != nil { 3278 ok := object.Key("roleArn") 3279 ok.String(*v.RoleArn) 3280 } 3281 3282 return nil 3283} 3284 3285func awsRestjson1_serializeDocumentMathActivity(v *types.MathActivity, value smithyjson.Value) error { 3286 object := value.Object() 3287 defer object.Close() 3288 3289 if v.Attribute != nil { 3290 ok := object.Key("attribute") 3291 ok.String(*v.Attribute) 3292 } 3293 3294 if v.Math != nil { 3295 ok := object.Key("math") 3296 ok.String(*v.Math) 3297 } 3298 3299 if v.Name != nil { 3300 ok := object.Key("name") 3301 ok.String(*v.Name) 3302 } 3303 3304 if v.Next != nil { 3305 ok := object.Key("next") 3306 ok.String(*v.Next) 3307 } 3308 3309 return nil 3310} 3311 3312func awsRestjson1_serializeDocumentMessage(v *types.Message, value smithyjson.Value) error { 3313 object := value.Object() 3314 defer object.Close() 3315 3316 if v.MessageId != nil { 3317 ok := object.Key("messageId") 3318 ok.String(*v.MessageId) 3319 } 3320 3321 if v.Payload != nil { 3322 ok := object.Key("payload") 3323 ok.Base64EncodeBytes(v.Payload) 3324 } 3325 3326 return nil 3327} 3328 3329func awsRestjson1_serializeDocumentMessagePayloads(v [][]byte, value smithyjson.Value) error { 3330 array := value.Array() 3331 defer array.Close() 3332 3333 for i := range v { 3334 av := array.Value() 3335 if vv := v[i]; vv == nil { 3336 continue 3337 } 3338 av.Base64EncodeBytes(v[i]) 3339 } 3340 return nil 3341} 3342 3343func awsRestjson1_serializeDocumentMessages(v []types.Message, value smithyjson.Value) error { 3344 array := value.Array() 3345 defer array.Close() 3346 3347 for i := range v { 3348 av := array.Value() 3349 if err := awsRestjson1_serializeDocumentMessage(&v[i], av); err != nil { 3350 return err 3351 } 3352 } 3353 return nil 3354} 3355 3356func awsRestjson1_serializeDocumentOutputFileUriValue(v *types.OutputFileUriValue, value smithyjson.Value) error { 3357 object := value.Object() 3358 defer object.Close() 3359 3360 if v.FileName != nil { 3361 ok := object.Key("fileName") 3362 ok.String(*v.FileName) 3363 } 3364 3365 return nil 3366} 3367 3368func awsRestjson1_serializeDocumentParquetConfiguration(v *types.ParquetConfiguration, value smithyjson.Value) error { 3369 object := value.Object() 3370 defer object.Close() 3371 3372 if v.SchemaDefinition != nil { 3373 ok := object.Key("schemaDefinition") 3374 if err := awsRestjson1_serializeDocumentSchemaDefinition(v.SchemaDefinition, ok); err != nil { 3375 return err 3376 } 3377 } 3378 3379 return nil 3380} 3381 3382func awsRestjson1_serializeDocumentPipelineActivities(v []types.PipelineActivity, value smithyjson.Value) error { 3383 array := value.Array() 3384 defer array.Close() 3385 3386 for i := range v { 3387 av := array.Value() 3388 if err := awsRestjson1_serializeDocumentPipelineActivity(&v[i], av); err != nil { 3389 return err 3390 } 3391 } 3392 return nil 3393} 3394 3395func awsRestjson1_serializeDocumentPipelineActivity(v *types.PipelineActivity, value smithyjson.Value) error { 3396 object := value.Object() 3397 defer object.Close() 3398 3399 if v.AddAttributes != nil { 3400 ok := object.Key("addAttributes") 3401 if err := awsRestjson1_serializeDocumentAddAttributesActivity(v.AddAttributes, ok); err != nil { 3402 return err 3403 } 3404 } 3405 3406 if v.Channel != nil { 3407 ok := object.Key("channel") 3408 if err := awsRestjson1_serializeDocumentChannelActivity(v.Channel, ok); err != nil { 3409 return err 3410 } 3411 } 3412 3413 if v.Datastore != nil { 3414 ok := object.Key("datastore") 3415 if err := awsRestjson1_serializeDocumentDatastoreActivity(v.Datastore, ok); err != nil { 3416 return err 3417 } 3418 } 3419 3420 if v.DeviceRegistryEnrich != nil { 3421 ok := object.Key("deviceRegistryEnrich") 3422 if err := awsRestjson1_serializeDocumentDeviceRegistryEnrichActivity(v.DeviceRegistryEnrich, ok); err != nil { 3423 return err 3424 } 3425 } 3426 3427 if v.DeviceShadowEnrich != nil { 3428 ok := object.Key("deviceShadowEnrich") 3429 if err := awsRestjson1_serializeDocumentDeviceShadowEnrichActivity(v.DeviceShadowEnrich, ok); err != nil { 3430 return err 3431 } 3432 } 3433 3434 if v.Filter != nil { 3435 ok := object.Key("filter") 3436 if err := awsRestjson1_serializeDocumentFilterActivity(v.Filter, ok); err != nil { 3437 return err 3438 } 3439 } 3440 3441 if v.Lambda != nil { 3442 ok := object.Key("lambda") 3443 if err := awsRestjson1_serializeDocumentLambdaActivity(v.Lambda, ok); err != nil { 3444 return err 3445 } 3446 } 3447 3448 if v.Math != nil { 3449 ok := object.Key("math") 3450 if err := awsRestjson1_serializeDocumentMathActivity(v.Math, ok); err != nil { 3451 return err 3452 } 3453 } 3454 3455 if v.RemoveAttributes != nil { 3456 ok := object.Key("removeAttributes") 3457 if err := awsRestjson1_serializeDocumentRemoveAttributesActivity(v.RemoveAttributes, ok); err != nil { 3458 return err 3459 } 3460 } 3461 3462 if v.SelectAttributes != nil { 3463 ok := object.Key("selectAttributes") 3464 if err := awsRestjson1_serializeDocumentSelectAttributesActivity(v.SelectAttributes, ok); err != nil { 3465 return err 3466 } 3467 } 3468 3469 return nil 3470} 3471 3472func awsRestjson1_serializeDocumentQueryFilter(v *types.QueryFilter, value smithyjson.Value) error { 3473 object := value.Object() 3474 defer object.Close() 3475 3476 if v.DeltaTime != nil { 3477 ok := object.Key("deltaTime") 3478 if err := awsRestjson1_serializeDocumentDeltaTime(v.DeltaTime, ok); err != nil { 3479 return err 3480 } 3481 } 3482 3483 return nil 3484} 3485 3486func awsRestjson1_serializeDocumentQueryFilters(v []types.QueryFilter, value smithyjson.Value) error { 3487 array := value.Array() 3488 defer array.Close() 3489 3490 for i := range v { 3491 av := array.Value() 3492 if err := awsRestjson1_serializeDocumentQueryFilter(&v[i], av); err != nil { 3493 return err 3494 } 3495 } 3496 return nil 3497} 3498 3499func awsRestjson1_serializeDocumentRemoveAttributesActivity(v *types.RemoveAttributesActivity, value smithyjson.Value) error { 3500 object := value.Object() 3501 defer object.Close() 3502 3503 if v.Attributes != nil { 3504 ok := object.Key("attributes") 3505 if err := awsRestjson1_serializeDocumentAttributeNames(v.Attributes, ok); err != nil { 3506 return err 3507 } 3508 } 3509 3510 if v.Name != nil { 3511 ok := object.Key("name") 3512 ok.String(*v.Name) 3513 } 3514 3515 if v.Next != nil { 3516 ok := object.Key("next") 3517 ok.String(*v.Next) 3518 } 3519 3520 return nil 3521} 3522 3523func awsRestjson1_serializeDocumentResourceConfiguration(v *types.ResourceConfiguration, value smithyjson.Value) error { 3524 object := value.Object() 3525 defer object.Close() 3526 3527 if len(v.ComputeType) > 0 { 3528 ok := object.Key("computeType") 3529 ok.String(string(v.ComputeType)) 3530 } 3531 3532 if v.VolumeSizeInGB != 0 { 3533 ok := object.Key("volumeSizeInGB") 3534 ok.Integer(v.VolumeSizeInGB) 3535 } 3536 3537 return nil 3538} 3539 3540func awsRestjson1_serializeDocumentRetentionPeriod(v *types.RetentionPeriod, value smithyjson.Value) error { 3541 object := value.Object() 3542 defer object.Close() 3543 3544 if v.NumberOfDays != nil { 3545 ok := object.Key("numberOfDays") 3546 ok.Integer(*v.NumberOfDays) 3547 } 3548 3549 if v.Unlimited { 3550 ok := object.Key("unlimited") 3551 ok.Boolean(v.Unlimited) 3552 } 3553 3554 return nil 3555} 3556 3557func awsRestjson1_serializeDocumentS3DestinationConfiguration(v *types.S3DestinationConfiguration, value smithyjson.Value) error { 3558 object := value.Object() 3559 defer object.Close() 3560 3561 if v.Bucket != nil { 3562 ok := object.Key("bucket") 3563 ok.String(*v.Bucket) 3564 } 3565 3566 if v.GlueConfiguration != nil { 3567 ok := object.Key("glueConfiguration") 3568 if err := awsRestjson1_serializeDocumentGlueConfiguration(v.GlueConfiguration, ok); err != nil { 3569 return err 3570 } 3571 } 3572 3573 if v.Key != nil { 3574 ok := object.Key("key") 3575 ok.String(*v.Key) 3576 } 3577 3578 if v.RoleArn != nil { 3579 ok := object.Key("roleArn") 3580 ok.String(*v.RoleArn) 3581 } 3582 3583 return nil 3584} 3585 3586func awsRestjson1_serializeDocumentS3PathChannelMessages(v []string, value smithyjson.Value) error { 3587 array := value.Array() 3588 defer array.Close() 3589 3590 for i := range v { 3591 av := array.Value() 3592 av.String(v[i]) 3593 } 3594 return nil 3595} 3596 3597func awsRestjson1_serializeDocumentSchedule(v *types.Schedule, value smithyjson.Value) error { 3598 object := value.Object() 3599 defer object.Close() 3600 3601 if v.Expression != nil { 3602 ok := object.Key("expression") 3603 ok.String(*v.Expression) 3604 } 3605 3606 return nil 3607} 3608 3609func awsRestjson1_serializeDocumentSchemaDefinition(v *types.SchemaDefinition, value smithyjson.Value) error { 3610 object := value.Object() 3611 defer object.Close() 3612 3613 if v.Columns != nil { 3614 ok := object.Key("columns") 3615 if err := awsRestjson1_serializeDocumentColumns(v.Columns, ok); err != nil { 3616 return err 3617 } 3618 } 3619 3620 return nil 3621} 3622 3623func awsRestjson1_serializeDocumentSelectAttributesActivity(v *types.SelectAttributesActivity, value smithyjson.Value) error { 3624 object := value.Object() 3625 defer object.Close() 3626 3627 if v.Attributes != nil { 3628 ok := object.Key("attributes") 3629 if err := awsRestjson1_serializeDocumentAttributeNames(v.Attributes, ok); err != nil { 3630 return err 3631 } 3632 } 3633 3634 if v.Name != nil { 3635 ok := object.Key("name") 3636 ok.String(*v.Name) 3637 } 3638 3639 if v.Next != nil { 3640 ok := object.Key("next") 3641 ok.String(*v.Next) 3642 } 3643 3644 return nil 3645} 3646 3647func awsRestjson1_serializeDocumentServiceManagedChannelS3Storage(v *types.ServiceManagedChannelS3Storage, value smithyjson.Value) error { 3648 object := value.Object() 3649 defer object.Close() 3650 3651 return nil 3652} 3653 3654func awsRestjson1_serializeDocumentServiceManagedDatastoreS3Storage(v *types.ServiceManagedDatastoreS3Storage, value smithyjson.Value) error { 3655 object := value.Object() 3656 defer object.Close() 3657 3658 return nil 3659} 3660 3661func awsRestjson1_serializeDocumentSqlQueryDatasetAction(v *types.SqlQueryDatasetAction, value smithyjson.Value) error { 3662 object := value.Object() 3663 defer object.Close() 3664 3665 if v.Filters != nil { 3666 ok := object.Key("filters") 3667 if err := awsRestjson1_serializeDocumentQueryFilters(v.Filters, ok); err != nil { 3668 return err 3669 } 3670 } 3671 3672 if v.SqlQuery != nil { 3673 ok := object.Key("sqlQuery") 3674 ok.String(*v.SqlQuery) 3675 } 3676 3677 return nil 3678} 3679 3680func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 3681 object := value.Object() 3682 defer object.Close() 3683 3684 if v.Key != nil { 3685 ok := object.Key("key") 3686 ok.String(*v.Key) 3687 } 3688 3689 if v.Value != nil { 3690 ok := object.Key("value") 3691 ok.String(*v.Value) 3692 } 3693 3694 return nil 3695} 3696 3697func awsRestjson1_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error { 3698 array := value.Array() 3699 defer array.Close() 3700 3701 for i := range v { 3702 av := array.Value() 3703 if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil { 3704 return err 3705 } 3706 } 3707 return nil 3708} 3709 3710func awsRestjson1_serializeDocumentTriggeringDataset(v *types.TriggeringDataset, value smithyjson.Value) error { 3711 object := value.Object() 3712 defer object.Close() 3713 3714 if v.Name != nil { 3715 ok := object.Key("name") 3716 ok.String(*v.Name) 3717 } 3718 3719 return nil 3720} 3721 3722func awsRestjson1_serializeDocumentVariable(v *types.Variable, value smithyjson.Value) error { 3723 object := value.Object() 3724 defer object.Close() 3725 3726 if v.DatasetContentVersionValue != nil { 3727 ok := object.Key("datasetContentVersionValue") 3728 if err := awsRestjson1_serializeDocumentDatasetContentVersionValue(v.DatasetContentVersionValue, ok); err != nil { 3729 return err 3730 } 3731 } 3732 3733 if v.DoubleValue != 0 { 3734 ok := object.Key("doubleValue") 3735 ok.Double(v.DoubleValue) 3736 } 3737 3738 if v.Name != nil { 3739 ok := object.Key("name") 3740 ok.String(*v.Name) 3741 } 3742 3743 if v.OutputFileUriValue != nil { 3744 ok := object.Key("outputFileUriValue") 3745 if err := awsRestjson1_serializeDocumentOutputFileUriValue(v.OutputFileUriValue, ok); err != nil { 3746 return err 3747 } 3748 } 3749 3750 if v.StringValue != nil { 3751 ok := object.Key("stringValue") 3752 ok.String(*v.StringValue) 3753 } 3754 3755 return nil 3756} 3757 3758func awsRestjson1_serializeDocumentVariables(v []types.Variable, value smithyjson.Value) error { 3759 array := value.Array() 3760 defer array.Close() 3761 3762 for i := range v { 3763 av := array.Value() 3764 if err := awsRestjson1_serializeDocumentVariable(&v[i], av); err != nil { 3765 return err 3766 } 3767 } 3768 return nil 3769} 3770 3771func awsRestjson1_serializeDocumentVersioningConfiguration(v *types.VersioningConfiguration, value smithyjson.Value) error { 3772 object := value.Object() 3773 defer object.Close() 3774 3775 if v.MaxVersions != nil { 3776 ok := object.Key("maxVersions") 3777 ok.Integer(*v.MaxVersions) 3778 } 3779 3780 if v.Unlimited { 3781 ok := object.Key("unlimited") 3782 ok.Boolean(v.Unlimited) 3783 } 3784 3785 return nil 3786} 3787