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