1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package robomaker 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/robomaker/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsRestjson1_serializeOpBatchDeleteWorlds struct { 18} 19 20func (*awsRestjson1_serializeOpBatchDeleteWorlds) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpBatchDeleteWorlds) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 25 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 26) { 27 request, ok := in.Request.(*smithyhttp.Request) 28 if !ok { 29 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 30 } 31 32 input, ok := in.Parameters.(*BatchDeleteWorldsInput) 33 _ = input 34 if !ok { 35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 36 } 37 38 opPath, opQuery := httpbinding.SplitURI("/batchDeleteWorlds") 39 request.URL.Path = opPath 40 if len(request.URL.RawQuery) > 0 { 41 request.URL.RawQuery = "&" + opQuery 42 } else { 43 request.URL.RawQuery = opQuery 44 } 45 46 request.Method = "POST" 47 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 48 if err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 restEncoder.SetHeader("Content-Type").String("application/json") 53 54 jsonEncoder := smithyjson.NewEncoder() 55 if err := awsRestjson1_serializeOpDocumentBatchDeleteWorldsInput(input, jsonEncoder.Value); err != nil { 56 return out, metadata, &smithy.SerializationError{Err: err} 57 } 58 59 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 63 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 64 return out, metadata, &smithy.SerializationError{Err: err} 65 } 66 in.Request = request 67 68 return next.HandleSerialize(ctx, in) 69} 70func awsRestjson1_serializeOpHttpBindingsBatchDeleteWorldsInput(v *BatchDeleteWorldsInput, encoder *httpbinding.Encoder) error { 71 if v == nil { 72 return fmt.Errorf("unsupported serialization of nil %T", v) 73 } 74 75 return nil 76} 77 78func awsRestjson1_serializeOpDocumentBatchDeleteWorldsInput(v *BatchDeleteWorldsInput, value smithyjson.Value) error { 79 object := value.Object() 80 defer object.Close() 81 82 if v.Worlds != nil { 83 ok := object.Key("worlds") 84 if err := awsRestjson1_serializeDocumentArns(v.Worlds, ok); err != nil { 85 return err 86 } 87 } 88 89 return nil 90} 91 92type awsRestjson1_serializeOpBatchDescribeSimulationJob struct { 93} 94 95func (*awsRestjson1_serializeOpBatchDescribeSimulationJob) ID() string { 96 return "OperationSerializer" 97} 98 99func (m *awsRestjson1_serializeOpBatchDescribeSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 100 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 101) { 102 request, ok := in.Request.(*smithyhttp.Request) 103 if !ok { 104 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 105 } 106 107 input, ok := in.Parameters.(*BatchDescribeSimulationJobInput) 108 _ = input 109 if !ok { 110 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 111 } 112 113 opPath, opQuery := httpbinding.SplitURI("/batchDescribeSimulationJob") 114 request.URL.Path = opPath 115 if len(request.URL.RawQuery) > 0 { 116 request.URL.RawQuery = "&" + opQuery 117 } else { 118 request.URL.RawQuery = opQuery 119 } 120 121 request.Method = "POST" 122 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 123 if err != nil { 124 return out, metadata, &smithy.SerializationError{Err: err} 125 } 126 127 restEncoder.SetHeader("Content-Type").String("application/json") 128 129 jsonEncoder := smithyjson.NewEncoder() 130 if err := awsRestjson1_serializeOpDocumentBatchDescribeSimulationJobInput(input, jsonEncoder.Value); err != nil { 131 return out, metadata, &smithy.SerializationError{Err: err} 132 } 133 134 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 135 return out, metadata, &smithy.SerializationError{Err: err} 136 } 137 138 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 139 return out, metadata, &smithy.SerializationError{Err: err} 140 } 141 in.Request = request 142 143 return next.HandleSerialize(ctx, in) 144} 145func awsRestjson1_serializeOpHttpBindingsBatchDescribeSimulationJobInput(v *BatchDescribeSimulationJobInput, encoder *httpbinding.Encoder) error { 146 if v == nil { 147 return fmt.Errorf("unsupported serialization of nil %T", v) 148 } 149 150 return nil 151} 152 153func awsRestjson1_serializeOpDocumentBatchDescribeSimulationJobInput(v *BatchDescribeSimulationJobInput, value smithyjson.Value) error { 154 object := value.Object() 155 defer object.Close() 156 157 if v.Jobs != nil { 158 ok := object.Key("jobs") 159 if err := awsRestjson1_serializeDocumentArns(v.Jobs, ok); err != nil { 160 return err 161 } 162 } 163 164 return nil 165} 166 167type awsRestjson1_serializeOpCancelDeploymentJob struct { 168} 169 170func (*awsRestjson1_serializeOpCancelDeploymentJob) ID() string { 171 return "OperationSerializer" 172} 173 174func (m *awsRestjson1_serializeOpCancelDeploymentJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 175 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 176) { 177 request, ok := in.Request.(*smithyhttp.Request) 178 if !ok { 179 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 180 } 181 182 input, ok := in.Parameters.(*CancelDeploymentJobInput) 183 _ = input 184 if !ok { 185 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 186 } 187 188 opPath, opQuery := httpbinding.SplitURI("/cancelDeploymentJob") 189 request.URL.Path = opPath 190 if len(request.URL.RawQuery) > 0 { 191 request.URL.RawQuery = "&" + opQuery 192 } else { 193 request.URL.RawQuery = opQuery 194 } 195 196 request.Method = "POST" 197 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 198 if err != nil { 199 return out, metadata, &smithy.SerializationError{Err: err} 200 } 201 202 restEncoder.SetHeader("Content-Type").String("application/json") 203 204 jsonEncoder := smithyjson.NewEncoder() 205 if err := awsRestjson1_serializeOpDocumentCancelDeploymentJobInput(input, jsonEncoder.Value); err != nil { 206 return out, metadata, &smithy.SerializationError{Err: err} 207 } 208 209 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 210 return out, metadata, &smithy.SerializationError{Err: err} 211 } 212 213 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 214 return out, metadata, &smithy.SerializationError{Err: err} 215 } 216 in.Request = request 217 218 return next.HandleSerialize(ctx, in) 219} 220func awsRestjson1_serializeOpHttpBindingsCancelDeploymentJobInput(v *CancelDeploymentJobInput, encoder *httpbinding.Encoder) error { 221 if v == nil { 222 return fmt.Errorf("unsupported serialization of nil %T", v) 223 } 224 225 return nil 226} 227 228func awsRestjson1_serializeOpDocumentCancelDeploymentJobInput(v *CancelDeploymentJobInput, value smithyjson.Value) error { 229 object := value.Object() 230 defer object.Close() 231 232 if v.Job != nil { 233 ok := object.Key("job") 234 ok.String(*v.Job) 235 } 236 237 return nil 238} 239 240type awsRestjson1_serializeOpCancelSimulationJob struct { 241} 242 243func (*awsRestjson1_serializeOpCancelSimulationJob) ID() string { 244 return "OperationSerializer" 245} 246 247func (m *awsRestjson1_serializeOpCancelSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 248 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 249) { 250 request, ok := in.Request.(*smithyhttp.Request) 251 if !ok { 252 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 253 } 254 255 input, ok := in.Parameters.(*CancelSimulationJobInput) 256 _ = input 257 if !ok { 258 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 259 } 260 261 opPath, opQuery := httpbinding.SplitURI("/cancelSimulationJob") 262 request.URL.Path = opPath 263 if len(request.URL.RawQuery) > 0 { 264 request.URL.RawQuery = "&" + opQuery 265 } else { 266 request.URL.RawQuery = opQuery 267 } 268 269 request.Method = "POST" 270 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 271 if err != nil { 272 return out, metadata, &smithy.SerializationError{Err: err} 273 } 274 275 restEncoder.SetHeader("Content-Type").String("application/json") 276 277 jsonEncoder := smithyjson.NewEncoder() 278 if err := awsRestjson1_serializeOpDocumentCancelSimulationJobInput(input, jsonEncoder.Value); err != nil { 279 return out, metadata, &smithy.SerializationError{Err: err} 280 } 281 282 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 283 return out, metadata, &smithy.SerializationError{Err: err} 284 } 285 286 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 287 return out, metadata, &smithy.SerializationError{Err: err} 288 } 289 in.Request = request 290 291 return next.HandleSerialize(ctx, in) 292} 293func awsRestjson1_serializeOpHttpBindingsCancelSimulationJobInput(v *CancelSimulationJobInput, encoder *httpbinding.Encoder) error { 294 if v == nil { 295 return fmt.Errorf("unsupported serialization of nil %T", v) 296 } 297 298 return nil 299} 300 301func awsRestjson1_serializeOpDocumentCancelSimulationJobInput(v *CancelSimulationJobInput, value smithyjson.Value) error { 302 object := value.Object() 303 defer object.Close() 304 305 if v.Job != nil { 306 ok := object.Key("job") 307 ok.String(*v.Job) 308 } 309 310 return nil 311} 312 313type awsRestjson1_serializeOpCancelSimulationJobBatch struct { 314} 315 316func (*awsRestjson1_serializeOpCancelSimulationJobBatch) ID() string { 317 return "OperationSerializer" 318} 319 320func (m *awsRestjson1_serializeOpCancelSimulationJobBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 321 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 322) { 323 request, ok := in.Request.(*smithyhttp.Request) 324 if !ok { 325 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 326 } 327 328 input, ok := in.Parameters.(*CancelSimulationJobBatchInput) 329 _ = input 330 if !ok { 331 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 332 } 333 334 opPath, opQuery := httpbinding.SplitURI("/cancelSimulationJobBatch") 335 request.URL.Path = opPath 336 if len(request.URL.RawQuery) > 0 { 337 request.URL.RawQuery = "&" + opQuery 338 } else { 339 request.URL.RawQuery = opQuery 340 } 341 342 request.Method = "POST" 343 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 344 if err != nil { 345 return out, metadata, &smithy.SerializationError{Err: err} 346 } 347 348 restEncoder.SetHeader("Content-Type").String("application/json") 349 350 jsonEncoder := smithyjson.NewEncoder() 351 if err := awsRestjson1_serializeOpDocumentCancelSimulationJobBatchInput(input, jsonEncoder.Value); err != nil { 352 return out, metadata, &smithy.SerializationError{Err: err} 353 } 354 355 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 356 return out, metadata, &smithy.SerializationError{Err: err} 357 } 358 359 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 360 return out, metadata, &smithy.SerializationError{Err: err} 361 } 362 in.Request = request 363 364 return next.HandleSerialize(ctx, in) 365} 366func awsRestjson1_serializeOpHttpBindingsCancelSimulationJobBatchInput(v *CancelSimulationJobBatchInput, encoder *httpbinding.Encoder) error { 367 if v == nil { 368 return fmt.Errorf("unsupported serialization of nil %T", v) 369 } 370 371 return nil 372} 373 374func awsRestjson1_serializeOpDocumentCancelSimulationJobBatchInput(v *CancelSimulationJobBatchInput, value smithyjson.Value) error { 375 object := value.Object() 376 defer object.Close() 377 378 if v.Batch != nil { 379 ok := object.Key("batch") 380 ok.String(*v.Batch) 381 } 382 383 return nil 384} 385 386type awsRestjson1_serializeOpCancelWorldExportJob struct { 387} 388 389func (*awsRestjson1_serializeOpCancelWorldExportJob) ID() string { 390 return "OperationSerializer" 391} 392 393func (m *awsRestjson1_serializeOpCancelWorldExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 394 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 395) { 396 request, ok := in.Request.(*smithyhttp.Request) 397 if !ok { 398 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 399 } 400 401 input, ok := in.Parameters.(*CancelWorldExportJobInput) 402 _ = input 403 if !ok { 404 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 405 } 406 407 opPath, opQuery := httpbinding.SplitURI("/cancelWorldExportJob") 408 request.URL.Path = opPath 409 if len(request.URL.RawQuery) > 0 { 410 request.URL.RawQuery = "&" + opQuery 411 } else { 412 request.URL.RawQuery = opQuery 413 } 414 415 request.Method = "POST" 416 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 417 if err != nil { 418 return out, metadata, &smithy.SerializationError{Err: err} 419 } 420 421 restEncoder.SetHeader("Content-Type").String("application/json") 422 423 jsonEncoder := smithyjson.NewEncoder() 424 if err := awsRestjson1_serializeOpDocumentCancelWorldExportJobInput(input, jsonEncoder.Value); err != nil { 425 return out, metadata, &smithy.SerializationError{Err: err} 426 } 427 428 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 429 return out, metadata, &smithy.SerializationError{Err: err} 430 } 431 432 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 433 return out, metadata, &smithy.SerializationError{Err: err} 434 } 435 in.Request = request 436 437 return next.HandleSerialize(ctx, in) 438} 439func awsRestjson1_serializeOpHttpBindingsCancelWorldExportJobInput(v *CancelWorldExportJobInput, encoder *httpbinding.Encoder) error { 440 if v == nil { 441 return fmt.Errorf("unsupported serialization of nil %T", v) 442 } 443 444 return nil 445} 446 447func awsRestjson1_serializeOpDocumentCancelWorldExportJobInput(v *CancelWorldExportJobInput, value smithyjson.Value) error { 448 object := value.Object() 449 defer object.Close() 450 451 if v.Job != nil { 452 ok := object.Key("job") 453 ok.String(*v.Job) 454 } 455 456 return nil 457} 458 459type awsRestjson1_serializeOpCancelWorldGenerationJob struct { 460} 461 462func (*awsRestjson1_serializeOpCancelWorldGenerationJob) ID() string { 463 return "OperationSerializer" 464} 465 466func (m *awsRestjson1_serializeOpCancelWorldGenerationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 467 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 468) { 469 request, ok := in.Request.(*smithyhttp.Request) 470 if !ok { 471 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 472 } 473 474 input, ok := in.Parameters.(*CancelWorldGenerationJobInput) 475 _ = input 476 if !ok { 477 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 478 } 479 480 opPath, opQuery := httpbinding.SplitURI("/cancelWorldGenerationJob") 481 request.URL.Path = opPath 482 if len(request.URL.RawQuery) > 0 { 483 request.URL.RawQuery = "&" + opQuery 484 } else { 485 request.URL.RawQuery = opQuery 486 } 487 488 request.Method = "POST" 489 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 490 if err != nil { 491 return out, metadata, &smithy.SerializationError{Err: err} 492 } 493 494 restEncoder.SetHeader("Content-Type").String("application/json") 495 496 jsonEncoder := smithyjson.NewEncoder() 497 if err := awsRestjson1_serializeOpDocumentCancelWorldGenerationJobInput(input, jsonEncoder.Value); err != nil { 498 return out, metadata, &smithy.SerializationError{Err: err} 499 } 500 501 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 502 return out, metadata, &smithy.SerializationError{Err: err} 503 } 504 505 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 506 return out, metadata, &smithy.SerializationError{Err: err} 507 } 508 in.Request = request 509 510 return next.HandleSerialize(ctx, in) 511} 512func awsRestjson1_serializeOpHttpBindingsCancelWorldGenerationJobInput(v *CancelWorldGenerationJobInput, encoder *httpbinding.Encoder) error { 513 if v == nil { 514 return fmt.Errorf("unsupported serialization of nil %T", v) 515 } 516 517 return nil 518} 519 520func awsRestjson1_serializeOpDocumentCancelWorldGenerationJobInput(v *CancelWorldGenerationJobInput, value smithyjson.Value) error { 521 object := value.Object() 522 defer object.Close() 523 524 if v.Job != nil { 525 ok := object.Key("job") 526 ok.String(*v.Job) 527 } 528 529 return nil 530} 531 532type awsRestjson1_serializeOpCreateDeploymentJob struct { 533} 534 535func (*awsRestjson1_serializeOpCreateDeploymentJob) ID() string { 536 return "OperationSerializer" 537} 538 539func (m *awsRestjson1_serializeOpCreateDeploymentJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 540 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 541) { 542 request, ok := in.Request.(*smithyhttp.Request) 543 if !ok { 544 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 545 } 546 547 input, ok := in.Parameters.(*CreateDeploymentJobInput) 548 _ = input 549 if !ok { 550 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 551 } 552 553 opPath, opQuery := httpbinding.SplitURI("/createDeploymentJob") 554 request.URL.Path = opPath 555 if len(request.URL.RawQuery) > 0 { 556 request.URL.RawQuery = "&" + opQuery 557 } else { 558 request.URL.RawQuery = opQuery 559 } 560 561 request.Method = "POST" 562 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 563 if err != nil { 564 return out, metadata, &smithy.SerializationError{Err: err} 565 } 566 567 restEncoder.SetHeader("Content-Type").String("application/json") 568 569 jsonEncoder := smithyjson.NewEncoder() 570 if err := awsRestjson1_serializeOpDocumentCreateDeploymentJobInput(input, jsonEncoder.Value); err != nil { 571 return out, metadata, &smithy.SerializationError{Err: err} 572 } 573 574 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 575 return out, metadata, &smithy.SerializationError{Err: err} 576 } 577 578 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 579 return out, metadata, &smithy.SerializationError{Err: err} 580 } 581 in.Request = request 582 583 return next.HandleSerialize(ctx, in) 584} 585func awsRestjson1_serializeOpHttpBindingsCreateDeploymentJobInput(v *CreateDeploymentJobInput, encoder *httpbinding.Encoder) error { 586 if v == nil { 587 return fmt.Errorf("unsupported serialization of nil %T", v) 588 } 589 590 return nil 591} 592 593func awsRestjson1_serializeOpDocumentCreateDeploymentJobInput(v *CreateDeploymentJobInput, value smithyjson.Value) error { 594 object := value.Object() 595 defer object.Close() 596 597 if v.ClientRequestToken != nil { 598 ok := object.Key("clientRequestToken") 599 ok.String(*v.ClientRequestToken) 600 } 601 602 if v.DeploymentApplicationConfigs != nil { 603 ok := object.Key("deploymentApplicationConfigs") 604 if err := awsRestjson1_serializeDocumentDeploymentApplicationConfigs(v.DeploymentApplicationConfigs, ok); err != nil { 605 return err 606 } 607 } 608 609 if v.DeploymentConfig != nil { 610 ok := object.Key("deploymentConfig") 611 if err := awsRestjson1_serializeDocumentDeploymentConfig(v.DeploymentConfig, ok); err != nil { 612 return err 613 } 614 } 615 616 if v.Fleet != nil { 617 ok := object.Key("fleet") 618 ok.String(*v.Fleet) 619 } 620 621 if v.Tags != nil { 622 ok := object.Key("tags") 623 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 624 return err 625 } 626 } 627 628 return nil 629} 630 631type awsRestjson1_serializeOpCreateFleet struct { 632} 633 634func (*awsRestjson1_serializeOpCreateFleet) ID() string { 635 return "OperationSerializer" 636} 637 638func (m *awsRestjson1_serializeOpCreateFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 639 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 640) { 641 request, ok := in.Request.(*smithyhttp.Request) 642 if !ok { 643 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 644 } 645 646 input, ok := in.Parameters.(*CreateFleetInput) 647 _ = input 648 if !ok { 649 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 650 } 651 652 opPath, opQuery := httpbinding.SplitURI("/createFleet") 653 request.URL.Path = opPath 654 if len(request.URL.RawQuery) > 0 { 655 request.URL.RawQuery = "&" + opQuery 656 } else { 657 request.URL.RawQuery = opQuery 658 } 659 660 request.Method = "POST" 661 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 662 if err != nil { 663 return out, metadata, &smithy.SerializationError{Err: err} 664 } 665 666 restEncoder.SetHeader("Content-Type").String("application/json") 667 668 jsonEncoder := smithyjson.NewEncoder() 669 if err := awsRestjson1_serializeOpDocumentCreateFleetInput(input, jsonEncoder.Value); err != nil { 670 return out, metadata, &smithy.SerializationError{Err: err} 671 } 672 673 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 674 return out, metadata, &smithy.SerializationError{Err: err} 675 } 676 677 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 678 return out, metadata, &smithy.SerializationError{Err: err} 679 } 680 in.Request = request 681 682 return next.HandleSerialize(ctx, in) 683} 684func awsRestjson1_serializeOpHttpBindingsCreateFleetInput(v *CreateFleetInput, encoder *httpbinding.Encoder) error { 685 if v == nil { 686 return fmt.Errorf("unsupported serialization of nil %T", v) 687 } 688 689 return nil 690} 691 692func awsRestjson1_serializeOpDocumentCreateFleetInput(v *CreateFleetInput, value smithyjson.Value) error { 693 object := value.Object() 694 defer object.Close() 695 696 if v.Name != nil { 697 ok := object.Key("name") 698 ok.String(*v.Name) 699 } 700 701 if v.Tags != nil { 702 ok := object.Key("tags") 703 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 704 return err 705 } 706 } 707 708 return nil 709} 710 711type awsRestjson1_serializeOpCreateRobot struct { 712} 713 714func (*awsRestjson1_serializeOpCreateRobot) ID() string { 715 return "OperationSerializer" 716} 717 718func (m *awsRestjson1_serializeOpCreateRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 719 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 720) { 721 request, ok := in.Request.(*smithyhttp.Request) 722 if !ok { 723 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 724 } 725 726 input, ok := in.Parameters.(*CreateRobotInput) 727 _ = input 728 if !ok { 729 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 730 } 731 732 opPath, opQuery := httpbinding.SplitURI("/createRobot") 733 request.URL.Path = opPath 734 if len(request.URL.RawQuery) > 0 { 735 request.URL.RawQuery = "&" + opQuery 736 } else { 737 request.URL.RawQuery = opQuery 738 } 739 740 request.Method = "POST" 741 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 742 if err != nil { 743 return out, metadata, &smithy.SerializationError{Err: err} 744 } 745 746 restEncoder.SetHeader("Content-Type").String("application/json") 747 748 jsonEncoder := smithyjson.NewEncoder() 749 if err := awsRestjson1_serializeOpDocumentCreateRobotInput(input, jsonEncoder.Value); err != nil { 750 return out, metadata, &smithy.SerializationError{Err: err} 751 } 752 753 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 754 return out, metadata, &smithy.SerializationError{Err: err} 755 } 756 757 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 758 return out, metadata, &smithy.SerializationError{Err: err} 759 } 760 in.Request = request 761 762 return next.HandleSerialize(ctx, in) 763} 764func awsRestjson1_serializeOpHttpBindingsCreateRobotInput(v *CreateRobotInput, encoder *httpbinding.Encoder) error { 765 if v == nil { 766 return fmt.Errorf("unsupported serialization of nil %T", v) 767 } 768 769 return nil 770} 771 772func awsRestjson1_serializeOpDocumentCreateRobotInput(v *CreateRobotInput, value smithyjson.Value) error { 773 object := value.Object() 774 defer object.Close() 775 776 if len(v.Architecture) > 0 { 777 ok := object.Key("architecture") 778 ok.String(string(v.Architecture)) 779 } 780 781 if v.GreengrassGroupId != nil { 782 ok := object.Key("greengrassGroupId") 783 ok.String(*v.GreengrassGroupId) 784 } 785 786 if v.Name != nil { 787 ok := object.Key("name") 788 ok.String(*v.Name) 789 } 790 791 if v.Tags != nil { 792 ok := object.Key("tags") 793 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 794 return err 795 } 796 } 797 798 return nil 799} 800 801type awsRestjson1_serializeOpCreateRobotApplication struct { 802} 803 804func (*awsRestjson1_serializeOpCreateRobotApplication) ID() string { 805 return "OperationSerializer" 806} 807 808func (m *awsRestjson1_serializeOpCreateRobotApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 809 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 810) { 811 request, ok := in.Request.(*smithyhttp.Request) 812 if !ok { 813 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 814 } 815 816 input, ok := in.Parameters.(*CreateRobotApplicationInput) 817 _ = input 818 if !ok { 819 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 820 } 821 822 opPath, opQuery := httpbinding.SplitURI("/createRobotApplication") 823 request.URL.Path = opPath 824 if len(request.URL.RawQuery) > 0 { 825 request.URL.RawQuery = "&" + opQuery 826 } else { 827 request.URL.RawQuery = opQuery 828 } 829 830 request.Method = "POST" 831 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 832 if err != nil { 833 return out, metadata, &smithy.SerializationError{Err: err} 834 } 835 836 restEncoder.SetHeader("Content-Type").String("application/json") 837 838 jsonEncoder := smithyjson.NewEncoder() 839 if err := awsRestjson1_serializeOpDocumentCreateRobotApplicationInput(input, jsonEncoder.Value); err != nil { 840 return out, metadata, &smithy.SerializationError{Err: err} 841 } 842 843 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 844 return out, metadata, &smithy.SerializationError{Err: err} 845 } 846 847 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 848 return out, metadata, &smithy.SerializationError{Err: err} 849 } 850 in.Request = request 851 852 return next.HandleSerialize(ctx, in) 853} 854func awsRestjson1_serializeOpHttpBindingsCreateRobotApplicationInput(v *CreateRobotApplicationInput, encoder *httpbinding.Encoder) error { 855 if v == nil { 856 return fmt.Errorf("unsupported serialization of nil %T", v) 857 } 858 859 return nil 860} 861 862func awsRestjson1_serializeOpDocumentCreateRobotApplicationInput(v *CreateRobotApplicationInput, value smithyjson.Value) error { 863 object := value.Object() 864 defer object.Close() 865 866 if v.Name != nil { 867 ok := object.Key("name") 868 ok.String(*v.Name) 869 } 870 871 if v.RobotSoftwareSuite != nil { 872 ok := object.Key("robotSoftwareSuite") 873 if err := awsRestjson1_serializeDocumentRobotSoftwareSuite(v.RobotSoftwareSuite, ok); err != nil { 874 return err 875 } 876 } 877 878 if v.Sources != nil { 879 ok := object.Key("sources") 880 if err := awsRestjson1_serializeDocumentSourceConfigs(v.Sources, ok); err != nil { 881 return err 882 } 883 } 884 885 if v.Tags != nil { 886 ok := object.Key("tags") 887 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 888 return err 889 } 890 } 891 892 return nil 893} 894 895type awsRestjson1_serializeOpCreateRobotApplicationVersion struct { 896} 897 898func (*awsRestjson1_serializeOpCreateRobotApplicationVersion) ID() string { 899 return "OperationSerializer" 900} 901 902func (m *awsRestjson1_serializeOpCreateRobotApplicationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 903 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 904) { 905 request, ok := in.Request.(*smithyhttp.Request) 906 if !ok { 907 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 908 } 909 910 input, ok := in.Parameters.(*CreateRobotApplicationVersionInput) 911 _ = input 912 if !ok { 913 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 914 } 915 916 opPath, opQuery := httpbinding.SplitURI("/createRobotApplicationVersion") 917 request.URL.Path = opPath 918 if len(request.URL.RawQuery) > 0 { 919 request.URL.RawQuery = "&" + opQuery 920 } else { 921 request.URL.RawQuery = opQuery 922 } 923 924 request.Method = "POST" 925 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 926 if err != nil { 927 return out, metadata, &smithy.SerializationError{Err: err} 928 } 929 930 restEncoder.SetHeader("Content-Type").String("application/json") 931 932 jsonEncoder := smithyjson.NewEncoder() 933 if err := awsRestjson1_serializeOpDocumentCreateRobotApplicationVersionInput(input, jsonEncoder.Value); err != nil { 934 return out, metadata, &smithy.SerializationError{Err: err} 935 } 936 937 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 938 return out, metadata, &smithy.SerializationError{Err: err} 939 } 940 941 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 942 return out, metadata, &smithy.SerializationError{Err: err} 943 } 944 in.Request = request 945 946 return next.HandleSerialize(ctx, in) 947} 948func awsRestjson1_serializeOpHttpBindingsCreateRobotApplicationVersionInput(v *CreateRobotApplicationVersionInput, encoder *httpbinding.Encoder) error { 949 if v == nil { 950 return fmt.Errorf("unsupported serialization of nil %T", v) 951 } 952 953 return nil 954} 955 956func awsRestjson1_serializeOpDocumentCreateRobotApplicationVersionInput(v *CreateRobotApplicationVersionInput, value smithyjson.Value) error { 957 object := value.Object() 958 defer object.Close() 959 960 if v.Application != nil { 961 ok := object.Key("application") 962 ok.String(*v.Application) 963 } 964 965 if v.CurrentRevisionId != nil { 966 ok := object.Key("currentRevisionId") 967 ok.String(*v.CurrentRevisionId) 968 } 969 970 return nil 971} 972 973type awsRestjson1_serializeOpCreateSimulationApplication struct { 974} 975 976func (*awsRestjson1_serializeOpCreateSimulationApplication) ID() string { 977 return "OperationSerializer" 978} 979 980func (m *awsRestjson1_serializeOpCreateSimulationApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 981 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 982) { 983 request, ok := in.Request.(*smithyhttp.Request) 984 if !ok { 985 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 986 } 987 988 input, ok := in.Parameters.(*CreateSimulationApplicationInput) 989 _ = input 990 if !ok { 991 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 992 } 993 994 opPath, opQuery := httpbinding.SplitURI("/createSimulationApplication") 995 request.URL.Path = opPath 996 if len(request.URL.RawQuery) > 0 { 997 request.URL.RawQuery = "&" + opQuery 998 } else { 999 request.URL.RawQuery = opQuery 1000 } 1001 1002 request.Method = "POST" 1003 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1004 if err != nil { 1005 return out, metadata, &smithy.SerializationError{Err: err} 1006 } 1007 1008 restEncoder.SetHeader("Content-Type").String("application/json") 1009 1010 jsonEncoder := smithyjson.NewEncoder() 1011 if err := awsRestjson1_serializeOpDocumentCreateSimulationApplicationInput(input, jsonEncoder.Value); err != nil { 1012 return out, metadata, &smithy.SerializationError{Err: err} 1013 } 1014 1015 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1016 return out, metadata, &smithy.SerializationError{Err: err} 1017 } 1018 1019 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1020 return out, metadata, &smithy.SerializationError{Err: err} 1021 } 1022 in.Request = request 1023 1024 return next.HandleSerialize(ctx, in) 1025} 1026func awsRestjson1_serializeOpHttpBindingsCreateSimulationApplicationInput(v *CreateSimulationApplicationInput, encoder *httpbinding.Encoder) error { 1027 if v == nil { 1028 return fmt.Errorf("unsupported serialization of nil %T", v) 1029 } 1030 1031 return nil 1032} 1033 1034func awsRestjson1_serializeOpDocumentCreateSimulationApplicationInput(v *CreateSimulationApplicationInput, value smithyjson.Value) error { 1035 object := value.Object() 1036 defer object.Close() 1037 1038 if v.Name != nil { 1039 ok := object.Key("name") 1040 ok.String(*v.Name) 1041 } 1042 1043 if v.RenderingEngine != nil { 1044 ok := object.Key("renderingEngine") 1045 if err := awsRestjson1_serializeDocumentRenderingEngine(v.RenderingEngine, ok); err != nil { 1046 return err 1047 } 1048 } 1049 1050 if v.RobotSoftwareSuite != nil { 1051 ok := object.Key("robotSoftwareSuite") 1052 if err := awsRestjson1_serializeDocumentRobotSoftwareSuite(v.RobotSoftwareSuite, ok); err != nil { 1053 return err 1054 } 1055 } 1056 1057 if v.SimulationSoftwareSuite != nil { 1058 ok := object.Key("simulationSoftwareSuite") 1059 if err := awsRestjson1_serializeDocumentSimulationSoftwareSuite(v.SimulationSoftwareSuite, ok); err != nil { 1060 return err 1061 } 1062 } 1063 1064 if v.Sources != nil { 1065 ok := object.Key("sources") 1066 if err := awsRestjson1_serializeDocumentSourceConfigs(v.Sources, ok); err != nil { 1067 return err 1068 } 1069 } 1070 1071 if v.Tags != nil { 1072 ok := object.Key("tags") 1073 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1074 return err 1075 } 1076 } 1077 1078 return nil 1079} 1080 1081type awsRestjson1_serializeOpCreateSimulationApplicationVersion struct { 1082} 1083 1084func (*awsRestjson1_serializeOpCreateSimulationApplicationVersion) ID() string { 1085 return "OperationSerializer" 1086} 1087 1088func (m *awsRestjson1_serializeOpCreateSimulationApplicationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1089 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1090) { 1091 request, ok := in.Request.(*smithyhttp.Request) 1092 if !ok { 1093 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1094 } 1095 1096 input, ok := in.Parameters.(*CreateSimulationApplicationVersionInput) 1097 _ = input 1098 if !ok { 1099 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1100 } 1101 1102 opPath, opQuery := httpbinding.SplitURI("/createSimulationApplicationVersion") 1103 request.URL.Path = opPath 1104 if len(request.URL.RawQuery) > 0 { 1105 request.URL.RawQuery = "&" + opQuery 1106 } else { 1107 request.URL.RawQuery = opQuery 1108 } 1109 1110 request.Method = "POST" 1111 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1112 if err != nil { 1113 return out, metadata, &smithy.SerializationError{Err: err} 1114 } 1115 1116 restEncoder.SetHeader("Content-Type").String("application/json") 1117 1118 jsonEncoder := smithyjson.NewEncoder() 1119 if err := awsRestjson1_serializeOpDocumentCreateSimulationApplicationVersionInput(input, jsonEncoder.Value); err != nil { 1120 return out, metadata, &smithy.SerializationError{Err: err} 1121 } 1122 1123 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1124 return out, metadata, &smithy.SerializationError{Err: err} 1125 } 1126 1127 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1128 return out, metadata, &smithy.SerializationError{Err: err} 1129 } 1130 in.Request = request 1131 1132 return next.HandleSerialize(ctx, in) 1133} 1134func awsRestjson1_serializeOpHttpBindingsCreateSimulationApplicationVersionInput(v *CreateSimulationApplicationVersionInput, encoder *httpbinding.Encoder) error { 1135 if v == nil { 1136 return fmt.Errorf("unsupported serialization of nil %T", v) 1137 } 1138 1139 return nil 1140} 1141 1142func awsRestjson1_serializeOpDocumentCreateSimulationApplicationVersionInput(v *CreateSimulationApplicationVersionInput, value smithyjson.Value) error { 1143 object := value.Object() 1144 defer object.Close() 1145 1146 if v.Application != nil { 1147 ok := object.Key("application") 1148 ok.String(*v.Application) 1149 } 1150 1151 if v.CurrentRevisionId != nil { 1152 ok := object.Key("currentRevisionId") 1153 ok.String(*v.CurrentRevisionId) 1154 } 1155 1156 return nil 1157} 1158 1159type awsRestjson1_serializeOpCreateSimulationJob struct { 1160} 1161 1162func (*awsRestjson1_serializeOpCreateSimulationJob) ID() string { 1163 return "OperationSerializer" 1164} 1165 1166func (m *awsRestjson1_serializeOpCreateSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1167 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1168) { 1169 request, ok := in.Request.(*smithyhttp.Request) 1170 if !ok { 1171 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1172 } 1173 1174 input, ok := in.Parameters.(*CreateSimulationJobInput) 1175 _ = input 1176 if !ok { 1177 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1178 } 1179 1180 opPath, opQuery := httpbinding.SplitURI("/createSimulationJob") 1181 request.URL.Path = opPath 1182 if len(request.URL.RawQuery) > 0 { 1183 request.URL.RawQuery = "&" + opQuery 1184 } else { 1185 request.URL.RawQuery = opQuery 1186 } 1187 1188 request.Method = "POST" 1189 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1190 if err != nil { 1191 return out, metadata, &smithy.SerializationError{Err: err} 1192 } 1193 1194 restEncoder.SetHeader("Content-Type").String("application/json") 1195 1196 jsonEncoder := smithyjson.NewEncoder() 1197 if err := awsRestjson1_serializeOpDocumentCreateSimulationJobInput(input, jsonEncoder.Value); err != nil { 1198 return out, metadata, &smithy.SerializationError{Err: err} 1199 } 1200 1201 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1202 return out, metadata, &smithy.SerializationError{Err: err} 1203 } 1204 1205 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1206 return out, metadata, &smithy.SerializationError{Err: err} 1207 } 1208 in.Request = request 1209 1210 return next.HandleSerialize(ctx, in) 1211} 1212func awsRestjson1_serializeOpHttpBindingsCreateSimulationJobInput(v *CreateSimulationJobInput, encoder *httpbinding.Encoder) error { 1213 if v == nil { 1214 return fmt.Errorf("unsupported serialization of nil %T", v) 1215 } 1216 1217 return nil 1218} 1219 1220func awsRestjson1_serializeOpDocumentCreateSimulationJobInput(v *CreateSimulationJobInput, value smithyjson.Value) error { 1221 object := value.Object() 1222 defer object.Close() 1223 1224 if v.ClientRequestToken != nil { 1225 ok := object.Key("clientRequestToken") 1226 ok.String(*v.ClientRequestToken) 1227 } 1228 1229 if v.Compute != nil { 1230 ok := object.Key("compute") 1231 if err := awsRestjson1_serializeDocumentCompute(v.Compute, ok); err != nil { 1232 return err 1233 } 1234 } 1235 1236 if v.DataSources != nil { 1237 ok := object.Key("dataSources") 1238 if err := awsRestjson1_serializeDocumentDataSourceConfigs(v.DataSources, ok); err != nil { 1239 return err 1240 } 1241 } 1242 1243 if len(v.FailureBehavior) > 0 { 1244 ok := object.Key("failureBehavior") 1245 ok.String(string(v.FailureBehavior)) 1246 } 1247 1248 if v.IamRole != nil { 1249 ok := object.Key("iamRole") 1250 ok.String(*v.IamRole) 1251 } 1252 1253 if v.LoggingConfig != nil { 1254 ok := object.Key("loggingConfig") 1255 if err := awsRestjson1_serializeDocumentLoggingConfig(v.LoggingConfig, ok); err != nil { 1256 return err 1257 } 1258 } 1259 1260 if v.MaxJobDurationInSeconds != 0 { 1261 ok := object.Key("maxJobDurationInSeconds") 1262 ok.Long(v.MaxJobDurationInSeconds) 1263 } 1264 1265 if v.OutputLocation != nil { 1266 ok := object.Key("outputLocation") 1267 if err := awsRestjson1_serializeDocumentOutputLocation(v.OutputLocation, ok); err != nil { 1268 return err 1269 } 1270 } 1271 1272 if v.RobotApplications != nil { 1273 ok := object.Key("robotApplications") 1274 if err := awsRestjson1_serializeDocumentRobotApplicationConfigs(v.RobotApplications, ok); err != nil { 1275 return err 1276 } 1277 } 1278 1279 if v.SimulationApplications != nil { 1280 ok := object.Key("simulationApplications") 1281 if err := awsRestjson1_serializeDocumentSimulationApplicationConfigs(v.SimulationApplications, ok); err != nil { 1282 return err 1283 } 1284 } 1285 1286 if v.Tags != nil { 1287 ok := object.Key("tags") 1288 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1289 return err 1290 } 1291 } 1292 1293 if v.VpcConfig != nil { 1294 ok := object.Key("vpcConfig") 1295 if err := awsRestjson1_serializeDocumentVPCConfig(v.VpcConfig, ok); err != nil { 1296 return err 1297 } 1298 } 1299 1300 return nil 1301} 1302 1303type awsRestjson1_serializeOpCreateWorldExportJob struct { 1304} 1305 1306func (*awsRestjson1_serializeOpCreateWorldExportJob) ID() string { 1307 return "OperationSerializer" 1308} 1309 1310func (m *awsRestjson1_serializeOpCreateWorldExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1311 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1312) { 1313 request, ok := in.Request.(*smithyhttp.Request) 1314 if !ok { 1315 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1316 } 1317 1318 input, ok := in.Parameters.(*CreateWorldExportJobInput) 1319 _ = input 1320 if !ok { 1321 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1322 } 1323 1324 opPath, opQuery := httpbinding.SplitURI("/createWorldExportJob") 1325 request.URL.Path = opPath 1326 if len(request.URL.RawQuery) > 0 { 1327 request.URL.RawQuery = "&" + opQuery 1328 } else { 1329 request.URL.RawQuery = opQuery 1330 } 1331 1332 request.Method = "POST" 1333 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1334 if err != nil { 1335 return out, metadata, &smithy.SerializationError{Err: err} 1336 } 1337 1338 restEncoder.SetHeader("Content-Type").String("application/json") 1339 1340 jsonEncoder := smithyjson.NewEncoder() 1341 if err := awsRestjson1_serializeOpDocumentCreateWorldExportJobInput(input, jsonEncoder.Value); err != nil { 1342 return out, metadata, &smithy.SerializationError{Err: err} 1343 } 1344 1345 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1346 return out, metadata, &smithy.SerializationError{Err: err} 1347 } 1348 1349 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1350 return out, metadata, &smithy.SerializationError{Err: err} 1351 } 1352 in.Request = request 1353 1354 return next.HandleSerialize(ctx, in) 1355} 1356func awsRestjson1_serializeOpHttpBindingsCreateWorldExportJobInput(v *CreateWorldExportJobInput, encoder *httpbinding.Encoder) error { 1357 if v == nil { 1358 return fmt.Errorf("unsupported serialization of nil %T", v) 1359 } 1360 1361 return nil 1362} 1363 1364func awsRestjson1_serializeOpDocumentCreateWorldExportJobInput(v *CreateWorldExportJobInput, value smithyjson.Value) error { 1365 object := value.Object() 1366 defer object.Close() 1367 1368 if v.ClientRequestToken != nil { 1369 ok := object.Key("clientRequestToken") 1370 ok.String(*v.ClientRequestToken) 1371 } 1372 1373 if v.IamRole != nil { 1374 ok := object.Key("iamRole") 1375 ok.String(*v.IamRole) 1376 } 1377 1378 if v.OutputLocation != nil { 1379 ok := object.Key("outputLocation") 1380 if err := awsRestjson1_serializeDocumentOutputLocation(v.OutputLocation, ok); err != nil { 1381 return err 1382 } 1383 } 1384 1385 if v.Tags != nil { 1386 ok := object.Key("tags") 1387 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1388 return err 1389 } 1390 } 1391 1392 if v.Worlds != nil { 1393 ok := object.Key("worlds") 1394 if err := awsRestjson1_serializeDocumentArns(v.Worlds, ok); err != nil { 1395 return err 1396 } 1397 } 1398 1399 return nil 1400} 1401 1402type awsRestjson1_serializeOpCreateWorldGenerationJob struct { 1403} 1404 1405func (*awsRestjson1_serializeOpCreateWorldGenerationJob) ID() string { 1406 return "OperationSerializer" 1407} 1408 1409func (m *awsRestjson1_serializeOpCreateWorldGenerationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1410 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1411) { 1412 request, ok := in.Request.(*smithyhttp.Request) 1413 if !ok { 1414 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1415 } 1416 1417 input, ok := in.Parameters.(*CreateWorldGenerationJobInput) 1418 _ = input 1419 if !ok { 1420 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1421 } 1422 1423 opPath, opQuery := httpbinding.SplitURI("/createWorldGenerationJob") 1424 request.URL.Path = opPath 1425 if len(request.URL.RawQuery) > 0 { 1426 request.URL.RawQuery = "&" + opQuery 1427 } else { 1428 request.URL.RawQuery = opQuery 1429 } 1430 1431 request.Method = "POST" 1432 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1433 if err != nil { 1434 return out, metadata, &smithy.SerializationError{Err: err} 1435 } 1436 1437 restEncoder.SetHeader("Content-Type").String("application/json") 1438 1439 jsonEncoder := smithyjson.NewEncoder() 1440 if err := awsRestjson1_serializeOpDocumentCreateWorldGenerationJobInput(input, jsonEncoder.Value); err != nil { 1441 return out, metadata, &smithy.SerializationError{Err: err} 1442 } 1443 1444 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1445 return out, metadata, &smithy.SerializationError{Err: err} 1446 } 1447 1448 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1449 return out, metadata, &smithy.SerializationError{Err: err} 1450 } 1451 in.Request = request 1452 1453 return next.HandleSerialize(ctx, in) 1454} 1455func awsRestjson1_serializeOpHttpBindingsCreateWorldGenerationJobInput(v *CreateWorldGenerationJobInput, encoder *httpbinding.Encoder) error { 1456 if v == nil { 1457 return fmt.Errorf("unsupported serialization of nil %T", v) 1458 } 1459 1460 return nil 1461} 1462 1463func awsRestjson1_serializeOpDocumentCreateWorldGenerationJobInput(v *CreateWorldGenerationJobInput, value smithyjson.Value) error { 1464 object := value.Object() 1465 defer object.Close() 1466 1467 if v.ClientRequestToken != nil { 1468 ok := object.Key("clientRequestToken") 1469 ok.String(*v.ClientRequestToken) 1470 } 1471 1472 if v.Tags != nil { 1473 ok := object.Key("tags") 1474 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1475 return err 1476 } 1477 } 1478 1479 if v.Template != nil { 1480 ok := object.Key("template") 1481 ok.String(*v.Template) 1482 } 1483 1484 if v.WorldCount != nil { 1485 ok := object.Key("worldCount") 1486 if err := awsRestjson1_serializeDocumentWorldCount(v.WorldCount, ok); err != nil { 1487 return err 1488 } 1489 } 1490 1491 if v.WorldTags != nil { 1492 ok := object.Key("worldTags") 1493 if err := awsRestjson1_serializeDocumentTagMap(v.WorldTags, ok); err != nil { 1494 return err 1495 } 1496 } 1497 1498 return nil 1499} 1500 1501type awsRestjson1_serializeOpCreateWorldTemplate struct { 1502} 1503 1504func (*awsRestjson1_serializeOpCreateWorldTemplate) ID() string { 1505 return "OperationSerializer" 1506} 1507 1508func (m *awsRestjson1_serializeOpCreateWorldTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1509 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1510) { 1511 request, ok := in.Request.(*smithyhttp.Request) 1512 if !ok { 1513 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1514 } 1515 1516 input, ok := in.Parameters.(*CreateWorldTemplateInput) 1517 _ = input 1518 if !ok { 1519 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1520 } 1521 1522 opPath, opQuery := httpbinding.SplitURI("/createWorldTemplate") 1523 request.URL.Path = opPath 1524 if len(request.URL.RawQuery) > 0 { 1525 request.URL.RawQuery = "&" + opQuery 1526 } else { 1527 request.URL.RawQuery = opQuery 1528 } 1529 1530 request.Method = "POST" 1531 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1532 if err != nil { 1533 return out, metadata, &smithy.SerializationError{Err: err} 1534 } 1535 1536 restEncoder.SetHeader("Content-Type").String("application/json") 1537 1538 jsonEncoder := smithyjson.NewEncoder() 1539 if err := awsRestjson1_serializeOpDocumentCreateWorldTemplateInput(input, jsonEncoder.Value); err != nil { 1540 return out, metadata, &smithy.SerializationError{Err: err} 1541 } 1542 1543 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1544 return out, metadata, &smithy.SerializationError{Err: err} 1545 } 1546 1547 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1548 return out, metadata, &smithy.SerializationError{Err: err} 1549 } 1550 in.Request = request 1551 1552 return next.HandleSerialize(ctx, in) 1553} 1554func awsRestjson1_serializeOpHttpBindingsCreateWorldTemplateInput(v *CreateWorldTemplateInput, encoder *httpbinding.Encoder) error { 1555 if v == nil { 1556 return fmt.Errorf("unsupported serialization of nil %T", v) 1557 } 1558 1559 return nil 1560} 1561 1562func awsRestjson1_serializeOpDocumentCreateWorldTemplateInput(v *CreateWorldTemplateInput, value smithyjson.Value) error { 1563 object := value.Object() 1564 defer object.Close() 1565 1566 if v.ClientRequestToken != nil { 1567 ok := object.Key("clientRequestToken") 1568 ok.String(*v.ClientRequestToken) 1569 } 1570 1571 if v.Name != nil { 1572 ok := object.Key("name") 1573 ok.String(*v.Name) 1574 } 1575 1576 if v.Tags != nil { 1577 ok := object.Key("tags") 1578 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1579 return err 1580 } 1581 } 1582 1583 if v.TemplateBody != nil { 1584 ok := object.Key("templateBody") 1585 ok.String(*v.TemplateBody) 1586 } 1587 1588 if v.TemplateLocation != nil { 1589 ok := object.Key("templateLocation") 1590 if err := awsRestjson1_serializeDocumentTemplateLocation(v.TemplateLocation, ok); err != nil { 1591 return err 1592 } 1593 } 1594 1595 return nil 1596} 1597 1598type awsRestjson1_serializeOpDeleteFleet struct { 1599} 1600 1601func (*awsRestjson1_serializeOpDeleteFleet) ID() string { 1602 return "OperationSerializer" 1603} 1604 1605func (m *awsRestjson1_serializeOpDeleteFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1606 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1607) { 1608 request, ok := in.Request.(*smithyhttp.Request) 1609 if !ok { 1610 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1611 } 1612 1613 input, ok := in.Parameters.(*DeleteFleetInput) 1614 _ = input 1615 if !ok { 1616 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1617 } 1618 1619 opPath, opQuery := httpbinding.SplitURI("/deleteFleet") 1620 request.URL.Path = opPath 1621 if len(request.URL.RawQuery) > 0 { 1622 request.URL.RawQuery = "&" + opQuery 1623 } else { 1624 request.URL.RawQuery = opQuery 1625 } 1626 1627 request.Method = "POST" 1628 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1629 if err != nil { 1630 return out, metadata, &smithy.SerializationError{Err: err} 1631 } 1632 1633 restEncoder.SetHeader("Content-Type").String("application/json") 1634 1635 jsonEncoder := smithyjson.NewEncoder() 1636 if err := awsRestjson1_serializeOpDocumentDeleteFleetInput(input, jsonEncoder.Value); err != nil { 1637 return out, metadata, &smithy.SerializationError{Err: err} 1638 } 1639 1640 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1641 return out, metadata, &smithy.SerializationError{Err: err} 1642 } 1643 1644 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1645 return out, metadata, &smithy.SerializationError{Err: err} 1646 } 1647 in.Request = request 1648 1649 return next.HandleSerialize(ctx, in) 1650} 1651func awsRestjson1_serializeOpHttpBindingsDeleteFleetInput(v *DeleteFleetInput, encoder *httpbinding.Encoder) error { 1652 if v == nil { 1653 return fmt.Errorf("unsupported serialization of nil %T", v) 1654 } 1655 1656 return nil 1657} 1658 1659func awsRestjson1_serializeOpDocumentDeleteFleetInput(v *DeleteFleetInput, value smithyjson.Value) error { 1660 object := value.Object() 1661 defer object.Close() 1662 1663 if v.Fleet != nil { 1664 ok := object.Key("fleet") 1665 ok.String(*v.Fleet) 1666 } 1667 1668 return nil 1669} 1670 1671type awsRestjson1_serializeOpDeleteRobot struct { 1672} 1673 1674func (*awsRestjson1_serializeOpDeleteRobot) ID() string { 1675 return "OperationSerializer" 1676} 1677 1678func (m *awsRestjson1_serializeOpDeleteRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1679 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1680) { 1681 request, ok := in.Request.(*smithyhttp.Request) 1682 if !ok { 1683 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1684 } 1685 1686 input, ok := in.Parameters.(*DeleteRobotInput) 1687 _ = input 1688 if !ok { 1689 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1690 } 1691 1692 opPath, opQuery := httpbinding.SplitURI("/deleteRobot") 1693 request.URL.Path = opPath 1694 if len(request.URL.RawQuery) > 0 { 1695 request.URL.RawQuery = "&" + opQuery 1696 } else { 1697 request.URL.RawQuery = opQuery 1698 } 1699 1700 request.Method = "POST" 1701 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1702 if err != nil { 1703 return out, metadata, &smithy.SerializationError{Err: err} 1704 } 1705 1706 restEncoder.SetHeader("Content-Type").String("application/json") 1707 1708 jsonEncoder := smithyjson.NewEncoder() 1709 if err := awsRestjson1_serializeOpDocumentDeleteRobotInput(input, jsonEncoder.Value); err != nil { 1710 return out, metadata, &smithy.SerializationError{Err: err} 1711 } 1712 1713 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1714 return out, metadata, &smithy.SerializationError{Err: err} 1715 } 1716 1717 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1718 return out, metadata, &smithy.SerializationError{Err: err} 1719 } 1720 in.Request = request 1721 1722 return next.HandleSerialize(ctx, in) 1723} 1724func awsRestjson1_serializeOpHttpBindingsDeleteRobotInput(v *DeleteRobotInput, encoder *httpbinding.Encoder) error { 1725 if v == nil { 1726 return fmt.Errorf("unsupported serialization of nil %T", v) 1727 } 1728 1729 return nil 1730} 1731 1732func awsRestjson1_serializeOpDocumentDeleteRobotInput(v *DeleteRobotInput, value smithyjson.Value) error { 1733 object := value.Object() 1734 defer object.Close() 1735 1736 if v.Robot != nil { 1737 ok := object.Key("robot") 1738 ok.String(*v.Robot) 1739 } 1740 1741 return nil 1742} 1743 1744type awsRestjson1_serializeOpDeleteRobotApplication struct { 1745} 1746 1747func (*awsRestjson1_serializeOpDeleteRobotApplication) ID() string { 1748 return "OperationSerializer" 1749} 1750 1751func (m *awsRestjson1_serializeOpDeleteRobotApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1752 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1753) { 1754 request, ok := in.Request.(*smithyhttp.Request) 1755 if !ok { 1756 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1757 } 1758 1759 input, ok := in.Parameters.(*DeleteRobotApplicationInput) 1760 _ = input 1761 if !ok { 1762 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1763 } 1764 1765 opPath, opQuery := httpbinding.SplitURI("/deleteRobotApplication") 1766 request.URL.Path = opPath 1767 if len(request.URL.RawQuery) > 0 { 1768 request.URL.RawQuery = "&" + opQuery 1769 } else { 1770 request.URL.RawQuery = opQuery 1771 } 1772 1773 request.Method = "POST" 1774 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1775 if err != nil { 1776 return out, metadata, &smithy.SerializationError{Err: err} 1777 } 1778 1779 restEncoder.SetHeader("Content-Type").String("application/json") 1780 1781 jsonEncoder := smithyjson.NewEncoder() 1782 if err := awsRestjson1_serializeOpDocumentDeleteRobotApplicationInput(input, jsonEncoder.Value); err != nil { 1783 return out, metadata, &smithy.SerializationError{Err: err} 1784 } 1785 1786 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1787 return out, metadata, &smithy.SerializationError{Err: err} 1788 } 1789 1790 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1791 return out, metadata, &smithy.SerializationError{Err: err} 1792 } 1793 in.Request = request 1794 1795 return next.HandleSerialize(ctx, in) 1796} 1797func awsRestjson1_serializeOpHttpBindingsDeleteRobotApplicationInput(v *DeleteRobotApplicationInput, encoder *httpbinding.Encoder) error { 1798 if v == nil { 1799 return fmt.Errorf("unsupported serialization of nil %T", v) 1800 } 1801 1802 return nil 1803} 1804 1805func awsRestjson1_serializeOpDocumentDeleteRobotApplicationInput(v *DeleteRobotApplicationInput, value smithyjson.Value) error { 1806 object := value.Object() 1807 defer object.Close() 1808 1809 if v.Application != nil { 1810 ok := object.Key("application") 1811 ok.String(*v.Application) 1812 } 1813 1814 if v.ApplicationVersion != nil { 1815 ok := object.Key("applicationVersion") 1816 ok.String(*v.ApplicationVersion) 1817 } 1818 1819 return nil 1820} 1821 1822type awsRestjson1_serializeOpDeleteSimulationApplication struct { 1823} 1824 1825func (*awsRestjson1_serializeOpDeleteSimulationApplication) ID() string { 1826 return "OperationSerializer" 1827} 1828 1829func (m *awsRestjson1_serializeOpDeleteSimulationApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1830 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1831) { 1832 request, ok := in.Request.(*smithyhttp.Request) 1833 if !ok { 1834 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1835 } 1836 1837 input, ok := in.Parameters.(*DeleteSimulationApplicationInput) 1838 _ = input 1839 if !ok { 1840 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1841 } 1842 1843 opPath, opQuery := httpbinding.SplitURI("/deleteSimulationApplication") 1844 request.URL.Path = opPath 1845 if len(request.URL.RawQuery) > 0 { 1846 request.URL.RawQuery = "&" + opQuery 1847 } else { 1848 request.URL.RawQuery = opQuery 1849 } 1850 1851 request.Method = "POST" 1852 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1853 if err != nil { 1854 return out, metadata, &smithy.SerializationError{Err: err} 1855 } 1856 1857 restEncoder.SetHeader("Content-Type").String("application/json") 1858 1859 jsonEncoder := smithyjson.NewEncoder() 1860 if err := awsRestjson1_serializeOpDocumentDeleteSimulationApplicationInput(input, jsonEncoder.Value); err != nil { 1861 return out, metadata, &smithy.SerializationError{Err: err} 1862 } 1863 1864 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1865 return out, metadata, &smithy.SerializationError{Err: err} 1866 } 1867 1868 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1869 return out, metadata, &smithy.SerializationError{Err: err} 1870 } 1871 in.Request = request 1872 1873 return next.HandleSerialize(ctx, in) 1874} 1875func awsRestjson1_serializeOpHttpBindingsDeleteSimulationApplicationInput(v *DeleteSimulationApplicationInput, encoder *httpbinding.Encoder) error { 1876 if v == nil { 1877 return fmt.Errorf("unsupported serialization of nil %T", v) 1878 } 1879 1880 return nil 1881} 1882 1883func awsRestjson1_serializeOpDocumentDeleteSimulationApplicationInput(v *DeleteSimulationApplicationInput, value smithyjson.Value) error { 1884 object := value.Object() 1885 defer object.Close() 1886 1887 if v.Application != nil { 1888 ok := object.Key("application") 1889 ok.String(*v.Application) 1890 } 1891 1892 if v.ApplicationVersion != nil { 1893 ok := object.Key("applicationVersion") 1894 ok.String(*v.ApplicationVersion) 1895 } 1896 1897 return nil 1898} 1899 1900type awsRestjson1_serializeOpDeleteWorldTemplate struct { 1901} 1902 1903func (*awsRestjson1_serializeOpDeleteWorldTemplate) ID() string { 1904 return "OperationSerializer" 1905} 1906 1907func (m *awsRestjson1_serializeOpDeleteWorldTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1908 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1909) { 1910 request, ok := in.Request.(*smithyhttp.Request) 1911 if !ok { 1912 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1913 } 1914 1915 input, ok := in.Parameters.(*DeleteWorldTemplateInput) 1916 _ = input 1917 if !ok { 1918 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1919 } 1920 1921 opPath, opQuery := httpbinding.SplitURI("/deleteWorldTemplate") 1922 request.URL.Path = opPath 1923 if len(request.URL.RawQuery) > 0 { 1924 request.URL.RawQuery = "&" + opQuery 1925 } else { 1926 request.URL.RawQuery = opQuery 1927 } 1928 1929 request.Method = "POST" 1930 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1931 if err != nil { 1932 return out, metadata, &smithy.SerializationError{Err: err} 1933 } 1934 1935 restEncoder.SetHeader("Content-Type").String("application/json") 1936 1937 jsonEncoder := smithyjson.NewEncoder() 1938 if err := awsRestjson1_serializeOpDocumentDeleteWorldTemplateInput(input, jsonEncoder.Value); err != nil { 1939 return out, metadata, &smithy.SerializationError{Err: err} 1940 } 1941 1942 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1943 return out, metadata, &smithy.SerializationError{Err: err} 1944 } 1945 1946 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1947 return out, metadata, &smithy.SerializationError{Err: err} 1948 } 1949 in.Request = request 1950 1951 return next.HandleSerialize(ctx, in) 1952} 1953func awsRestjson1_serializeOpHttpBindingsDeleteWorldTemplateInput(v *DeleteWorldTemplateInput, encoder *httpbinding.Encoder) error { 1954 if v == nil { 1955 return fmt.Errorf("unsupported serialization of nil %T", v) 1956 } 1957 1958 return nil 1959} 1960 1961func awsRestjson1_serializeOpDocumentDeleteWorldTemplateInput(v *DeleteWorldTemplateInput, value smithyjson.Value) error { 1962 object := value.Object() 1963 defer object.Close() 1964 1965 if v.Template != nil { 1966 ok := object.Key("template") 1967 ok.String(*v.Template) 1968 } 1969 1970 return nil 1971} 1972 1973type awsRestjson1_serializeOpDeregisterRobot struct { 1974} 1975 1976func (*awsRestjson1_serializeOpDeregisterRobot) ID() string { 1977 return "OperationSerializer" 1978} 1979 1980func (m *awsRestjson1_serializeOpDeregisterRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1981 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1982) { 1983 request, ok := in.Request.(*smithyhttp.Request) 1984 if !ok { 1985 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1986 } 1987 1988 input, ok := in.Parameters.(*DeregisterRobotInput) 1989 _ = input 1990 if !ok { 1991 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1992 } 1993 1994 opPath, opQuery := httpbinding.SplitURI("/deregisterRobot") 1995 request.URL.Path = opPath 1996 if len(request.URL.RawQuery) > 0 { 1997 request.URL.RawQuery = "&" + opQuery 1998 } else { 1999 request.URL.RawQuery = opQuery 2000 } 2001 2002 request.Method = "POST" 2003 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2004 if err != nil { 2005 return out, metadata, &smithy.SerializationError{Err: err} 2006 } 2007 2008 restEncoder.SetHeader("Content-Type").String("application/json") 2009 2010 jsonEncoder := smithyjson.NewEncoder() 2011 if err := awsRestjson1_serializeOpDocumentDeregisterRobotInput(input, jsonEncoder.Value); err != nil { 2012 return out, metadata, &smithy.SerializationError{Err: err} 2013 } 2014 2015 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2016 return out, metadata, &smithy.SerializationError{Err: err} 2017 } 2018 2019 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2020 return out, metadata, &smithy.SerializationError{Err: err} 2021 } 2022 in.Request = request 2023 2024 return next.HandleSerialize(ctx, in) 2025} 2026func awsRestjson1_serializeOpHttpBindingsDeregisterRobotInput(v *DeregisterRobotInput, encoder *httpbinding.Encoder) error { 2027 if v == nil { 2028 return fmt.Errorf("unsupported serialization of nil %T", v) 2029 } 2030 2031 return nil 2032} 2033 2034func awsRestjson1_serializeOpDocumentDeregisterRobotInput(v *DeregisterRobotInput, value smithyjson.Value) error { 2035 object := value.Object() 2036 defer object.Close() 2037 2038 if v.Fleet != nil { 2039 ok := object.Key("fleet") 2040 ok.String(*v.Fleet) 2041 } 2042 2043 if v.Robot != nil { 2044 ok := object.Key("robot") 2045 ok.String(*v.Robot) 2046 } 2047 2048 return nil 2049} 2050 2051type awsRestjson1_serializeOpDescribeDeploymentJob struct { 2052} 2053 2054func (*awsRestjson1_serializeOpDescribeDeploymentJob) ID() string { 2055 return "OperationSerializer" 2056} 2057 2058func (m *awsRestjson1_serializeOpDescribeDeploymentJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2059 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2060) { 2061 request, ok := in.Request.(*smithyhttp.Request) 2062 if !ok { 2063 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2064 } 2065 2066 input, ok := in.Parameters.(*DescribeDeploymentJobInput) 2067 _ = input 2068 if !ok { 2069 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2070 } 2071 2072 opPath, opQuery := httpbinding.SplitURI("/describeDeploymentJob") 2073 request.URL.Path = opPath 2074 if len(request.URL.RawQuery) > 0 { 2075 request.URL.RawQuery = "&" + opQuery 2076 } else { 2077 request.URL.RawQuery = opQuery 2078 } 2079 2080 request.Method = "POST" 2081 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2082 if err != nil { 2083 return out, metadata, &smithy.SerializationError{Err: err} 2084 } 2085 2086 restEncoder.SetHeader("Content-Type").String("application/json") 2087 2088 jsonEncoder := smithyjson.NewEncoder() 2089 if err := awsRestjson1_serializeOpDocumentDescribeDeploymentJobInput(input, jsonEncoder.Value); err != nil { 2090 return out, metadata, &smithy.SerializationError{Err: err} 2091 } 2092 2093 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2094 return out, metadata, &smithy.SerializationError{Err: err} 2095 } 2096 2097 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2098 return out, metadata, &smithy.SerializationError{Err: err} 2099 } 2100 in.Request = request 2101 2102 return next.HandleSerialize(ctx, in) 2103} 2104func awsRestjson1_serializeOpHttpBindingsDescribeDeploymentJobInput(v *DescribeDeploymentJobInput, encoder *httpbinding.Encoder) error { 2105 if v == nil { 2106 return fmt.Errorf("unsupported serialization of nil %T", v) 2107 } 2108 2109 return nil 2110} 2111 2112func awsRestjson1_serializeOpDocumentDescribeDeploymentJobInput(v *DescribeDeploymentJobInput, value smithyjson.Value) error { 2113 object := value.Object() 2114 defer object.Close() 2115 2116 if v.Job != nil { 2117 ok := object.Key("job") 2118 ok.String(*v.Job) 2119 } 2120 2121 return nil 2122} 2123 2124type awsRestjson1_serializeOpDescribeFleet struct { 2125} 2126 2127func (*awsRestjson1_serializeOpDescribeFleet) ID() string { 2128 return "OperationSerializer" 2129} 2130 2131func (m *awsRestjson1_serializeOpDescribeFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2132 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2133) { 2134 request, ok := in.Request.(*smithyhttp.Request) 2135 if !ok { 2136 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2137 } 2138 2139 input, ok := in.Parameters.(*DescribeFleetInput) 2140 _ = input 2141 if !ok { 2142 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2143 } 2144 2145 opPath, opQuery := httpbinding.SplitURI("/describeFleet") 2146 request.URL.Path = opPath 2147 if len(request.URL.RawQuery) > 0 { 2148 request.URL.RawQuery = "&" + opQuery 2149 } else { 2150 request.URL.RawQuery = opQuery 2151 } 2152 2153 request.Method = "POST" 2154 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2155 if err != nil { 2156 return out, metadata, &smithy.SerializationError{Err: err} 2157 } 2158 2159 restEncoder.SetHeader("Content-Type").String("application/json") 2160 2161 jsonEncoder := smithyjson.NewEncoder() 2162 if err := awsRestjson1_serializeOpDocumentDescribeFleetInput(input, jsonEncoder.Value); err != nil { 2163 return out, metadata, &smithy.SerializationError{Err: err} 2164 } 2165 2166 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2167 return out, metadata, &smithy.SerializationError{Err: err} 2168 } 2169 2170 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2171 return out, metadata, &smithy.SerializationError{Err: err} 2172 } 2173 in.Request = request 2174 2175 return next.HandleSerialize(ctx, in) 2176} 2177func awsRestjson1_serializeOpHttpBindingsDescribeFleetInput(v *DescribeFleetInput, encoder *httpbinding.Encoder) error { 2178 if v == nil { 2179 return fmt.Errorf("unsupported serialization of nil %T", v) 2180 } 2181 2182 return nil 2183} 2184 2185func awsRestjson1_serializeOpDocumentDescribeFleetInput(v *DescribeFleetInput, value smithyjson.Value) error { 2186 object := value.Object() 2187 defer object.Close() 2188 2189 if v.Fleet != nil { 2190 ok := object.Key("fleet") 2191 ok.String(*v.Fleet) 2192 } 2193 2194 return nil 2195} 2196 2197type awsRestjson1_serializeOpDescribeRobot struct { 2198} 2199 2200func (*awsRestjson1_serializeOpDescribeRobot) ID() string { 2201 return "OperationSerializer" 2202} 2203 2204func (m *awsRestjson1_serializeOpDescribeRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2205 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2206) { 2207 request, ok := in.Request.(*smithyhttp.Request) 2208 if !ok { 2209 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2210 } 2211 2212 input, ok := in.Parameters.(*DescribeRobotInput) 2213 _ = input 2214 if !ok { 2215 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2216 } 2217 2218 opPath, opQuery := httpbinding.SplitURI("/describeRobot") 2219 request.URL.Path = opPath 2220 if len(request.URL.RawQuery) > 0 { 2221 request.URL.RawQuery = "&" + opQuery 2222 } else { 2223 request.URL.RawQuery = opQuery 2224 } 2225 2226 request.Method = "POST" 2227 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2228 if err != nil { 2229 return out, metadata, &smithy.SerializationError{Err: err} 2230 } 2231 2232 restEncoder.SetHeader("Content-Type").String("application/json") 2233 2234 jsonEncoder := smithyjson.NewEncoder() 2235 if err := awsRestjson1_serializeOpDocumentDescribeRobotInput(input, jsonEncoder.Value); err != nil { 2236 return out, metadata, &smithy.SerializationError{Err: err} 2237 } 2238 2239 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2240 return out, metadata, &smithy.SerializationError{Err: err} 2241 } 2242 2243 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2244 return out, metadata, &smithy.SerializationError{Err: err} 2245 } 2246 in.Request = request 2247 2248 return next.HandleSerialize(ctx, in) 2249} 2250func awsRestjson1_serializeOpHttpBindingsDescribeRobotInput(v *DescribeRobotInput, encoder *httpbinding.Encoder) error { 2251 if v == nil { 2252 return fmt.Errorf("unsupported serialization of nil %T", v) 2253 } 2254 2255 return nil 2256} 2257 2258func awsRestjson1_serializeOpDocumentDescribeRobotInput(v *DescribeRobotInput, value smithyjson.Value) error { 2259 object := value.Object() 2260 defer object.Close() 2261 2262 if v.Robot != nil { 2263 ok := object.Key("robot") 2264 ok.String(*v.Robot) 2265 } 2266 2267 return nil 2268} 2269 2270type awsRestjson1_serializeOpDescribeRobotApplication struct { 2271} 2272 2273func (*awsRestjson1_serializeOpDescribeRobotApplication) ID() string { 2274 return "OperationSerializer" 2275} 2276 2277func (m *awsRestjson1_serializeOpDescribeRobotApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2278 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2279) { 2280 request, ok := in.Request.(*smithyhttp.Request) 2281 if !ok { 2282 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2283 } 2284 2285 input, ok := in.Parameters.(*DescribeRobotApplicationInput) 2286 _ = input 2287 if !ok { 2288 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2289 } 2290 2291 opPath, opQuery := httpbinding.SplitURI("/describeRobotApplication") 2292 request.URL.Path = opPath 2293 if len(request.URL.RawQuery) > 0 { 2294 request.URL.RawQuery = "&" + opQuery 2295 } else { 2296 request.URL.RawQuery = opQuery 2297 } 2298 2299 request.Method = "POST" 2300 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2301 if err != nil { 2302 return out, metadata, &smithy.SerializationError{Err: err} 2303 } 2304 2305 restEncoder.SetHeader("Content-Type").String("application/json") 2306 2307 jsonEncoder := smithyjson.NewEncoder() 2308 if err := awsRestjson1_serializeOpDocumentDescribeRobotApplicationInput(input, jsonEncoder.Value); err != nil { 2309 return out, metadata, &smithy.SerializationError{Err: err} 2310 } 2311 2312 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2313 return out, metadata, &smithy.SerializationError{Err: err} 2314 } 2315 2316 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2317 return out, metadata, &smithy.SerializationError{Err: err} 2318 } 2319 in.Request = request 2320 2321 return next.HandleSerialize(ctx, in) 2322} 2323func awsRestjson1_serializeOpHttpBindingsDescribeRobotApplicationInput(v *DescribeRobotApplicationInput, encoder *httpbinding.Encoder) error { 2324 if v == nil { 2325 return fmt.Errorf("unsupported serialization of nil %T", v) 2326 } 2327 2328 return nil 2329} 2330 2331func awsRestjson1_serializeOpDocumentDescribeRobotApplicationInput(v *DescribeRobotApplicationInput, value smithyjson.Value) error { 2332 object := value.Object() 2333 defer object.Close() 2334 2335 if v.Application != nil { 2336 ok := object.Key("application") 2337 ok.String(*v.Application) 2338 } 2339 2340 if v.ApplicationVersion != nil { 2341 ok := object.Key("applicationVersion") 2342 ok.String(*v.ApplicationVersion) 2343 } 2344 2345 return nil 2346} 2347 2348type awsRestjson1_serializeOpDescribeSimulationApplication struct { 2349} 2350 2351func (*awsRestjson1_serializeOpDescribeSimulationApplication) ID() string { 2352 return "OperationSerializer" 2353} 2354 2355func (m *awsRestjson1_serializeOpDescribeSimulationApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2356 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2357) { 2358 request, ok := in.Request.(*smithyhttp.Request) 2359 if !ok { 2360 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2361 } 2362 2363 input, ok := in.Parameters.(*DescribeSimulationApplicationInput) 2364 _ = input 2365 if !ok { 2366 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2367 } 2368 2369 opPath, opQuery := httpbinding.SplitURI("/describeSimulationApplication") 2370 request.URL.Path = opPath 2371 if len(request.URL.RawQuery) > 0 { 2372 request.URL.RawQuery = "&" + opQuery 2373 } else { 2374 request.URL.RawQuery = opQuery 2375 } 2376 2377 request.Method = "POST" 2378 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2379 if err != nil { 2380 return out, metadata, &smithy.SerializationError{Err: err} 2381 } 2382 2383 restEncoder.SetHeader("Content-Type").String("application/json") 2384 2385 jsonEncoder := smithyjson.NewEncoder() 2386 if err := awsRestjson1_serializeOpDocumentDescribeSimulationApplicationInput(input, jsonEncoder.Value); err != nil { 2387 return out, metadata, &smithy.SerializationError{Err: err} 2388 } 2389 2390 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2391 return out, metadata, &smithy.SerializationError{Err: err} 2392 } 2393 2394 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2395 return out, metadata, &smithy.SerializationError{Err: err} 2396 } 2397 in.Request = request 2398 2399 return next.HandleSerialize(ctx, in) 2400} 2401func awsRestjson1_serializeOpHttpBindingsDescribeSimulationApplicationInput(v *DescribeSimulationApplicationInput, encoder *httpbinding.Encoder) error { 2402 if v == nil { 2403 return fmt.Errorf("unsupported serialization of nil %T", v) 2404 } 2405 2406 return nil 2407} 2408 2409func awsRestjson1_serializeOpDocumentDescribeSimulationApplicationInput(v *DescribeSimulationApplicationInput, value smithyjson.Value) error { 2410 object := value.Object() 2411 defer object.Close() 2412 2413 if v.Application != nil { 2414 ok := object.Key("application") 2415 ok.String(*v.Application) 2416 } 2417 2418 if v.ApplicationVersion != nil { 2419 ok := object.Key("applicationVersion") 2420 ok.String(*v.ApplicationVersion) 2421 } 2422 2423 return nil 2424} 2425 2426type awsRestjson1_serializeOpDescribeSimulationJob struct { 2427} 2428 2429func (*awsRestjson1_serializeOpDescribeSimulationJob) ID() string { 2430 return "OperationSerializer" 2431} 2432 2433func (m *awsRestjson1_serializeOpDescribeSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2434 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2435) { 2436 request, ok := in.Request.(*smithyhttp.Request) 2437 if !ok { 2438 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2439 } 2440 2441 input, ok := in.Parameters.(*DescribeSimulationJobInput) 2442 _ = input 2443 if !ok { 2444 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2445 } 2446 2447 opPath, opQuery := httpbinding.SplitURI("/describeSimulationJob") 2448 request.URL.Path = opPath 2449 if len(request.URL.RawQuery) > 0 { 2450 request.URL.RawQuery = "&" + opQuery 2451 } else { 2452 request.URL.RawQuery = opQuery 2453 } 2454 2455 request.Method = "POST" 2456 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2457 if err != nil { 2458 return out, metadata, &smithy.SerializationError{Err: err} 2459 } 2460 2461 restEncoder.SetHeader("Content-Type").String("application/json") 2462 2463 jsonEncoder := smithyjson.NewEncoder() 2464 if err := awsRestjson1_serializeOpDocumentDescribeSimulationJobInput(input, jsonEncoder.Value); err != nil { 2465 return out, metadata, &smithy.SerializationError{Err: err} 2466 } 2467 2468 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2469 return out, metadata, &smithy.SerializationError{Err: err} 2470 } 2471 2472 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2473 return out, metadata, &smithy.SerializationError{Err: err} 2474 } 2475 in.Request = request 2476 2477 return next.HandleSerialize(ctx, in) 2478} 2479func awsRestjson1_serializeOpHttpBindingsDescribeSimulationJobInput(v *DescribeSimulationJobInput, encoder *httpbinding.Encoder) error { 2480 if v == nil { 2481 return fmt.Errorf("unsupported serialization of nil %T", v) 2482 } 2483 2484 return nil 2485} 2486 2487func awsRestjson1_serializeOpDocumentDescribeSimulationJobInput(v *DescribeSimulationJobInput, value smithyjson.Value) error { 2488 object := value.Object() 2489 defer object.Close() 2490 2491 if v.Job != nil { 2492 ok := object.Key("job") 2493 ok.String(*v.Job) 2494 } 2495 2496 return nil 2497} 2498 2499type awsRestjson1_serializeOpDescribeSimulationJobBatch struct { 2500} 2501 2502func (*awsRestjson1_serializeOpDescribeSimulationJobBatch) ID() string { 2503 return "OperationSerializer" 2504} 2505 2506func (m *awsRestjson1_serializeOpDescribeSimulationJobBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2507 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2508) { 2509 request, ok := in.Request.(*smithyhttp.Request) 2510 if !ok { 2511 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2512 } 2513 2514 input, ok := in.Parameters.(*DescribeSimulationJobBatchInput) 2515 _ = input 2516 if !ok { 2517 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2518 } 2519 2520 opPath, opQuery := httpbinding.SplitURI("/describeSimulationJobBatch") 2521 request.URL.Path = opPath 2522 if len(request.URL.RawQuery) > 0 { 2523 request.URL.RawQuery = "&" + opQuery 2524 } else { 2525 request.URL.RawQuery = opQuery 2526 } 2527 2528 request.Method = "POST" 2529 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2530 if err != nil { 2531 return out, metadata, &smithy.SerializationError{Err: err} 2532 } 2533 2534 restEncoder.SetHeader("Content-Type").String("application/json") 2535 2536 jsonEncoder := smithyjson.NewEncoder() 2537 if err := awsRestjson1_serializeOpDocumentDescribeSimulationJobBatchInput(input, jsonEncoder.Value); err != nil { 2538 return out, metadata, &smithy.SerializationError{Err: err} 2539 } 2540 2541 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2542 return out, metadata, &smithy.SerializationError{Err: err} 2543 } 2544 2545 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2546 return out, metadata, &smithy.SerializationError{Err: err} 2547 } 2548 in.Request = request 2549 2550 return next.HandleSerialize(ctx, in) 2551} 2552func awsRestjson1_serializeOpHttpBindingsDescribeSimulationJobBatchInput(v *DescribeSimulationJobBatchInput, encoder *httpbinding.Encoder) error { 2553 if v == nil { 2554 return fmt.Errorf("unsupported serialization of nil %T", v) 2555 } 2556 2557 return nil 2558} 2559 2560func awsRestjson1_serializeOpDocumentDescribeSimulationJobBatchInput(v *DescribeSimulationJobBatchInput, value smithyjson.Value) error { 2561 object := value.Object() 2562 defer object.Close() 2563 2564 if v.Batch != nil { 2565 ok := object.Key("batch") 2566 ok.String(*v.Batch) 2567 } 2568 2569 return nil 2570} 2571 2572type awsRestjson1_serializeOpDescribeWorld struct { 2573} 2574 2575func (*awsRestjson1_serializeOpDescribeWorld) ID() string { 2576 return "OperationSerializer" 2577} 2578 2579func (m *awsRestjson1_serializeOpDescribeWorld) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2580 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2581) { 2582 request, ok := in.Request.(*smithyhttp.Request) 2583 if !ok { 2584 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2585 } 2586 2587 input, ok := in.Parameters.(*DescribeWorldInput) 2588 _ = input 2589 if !ok { 2590 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2591 } 2592 2593 opPath, opQuery := httpbinding.SplitURI("/describeWorld") 2594 request.URL.Path = opPath 2595 if len(request.URL.RawQuery) > 0 { 2596 request.URL.RawQuery = "&" + opQuery 2597 } else { 2598 request.URL.RawQuery = opQuery 2599 } 2600 2601 request.Method = "POST" 2602 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2603 if err != nil { 2604 return out, metadata, &smithy.SerializationError{Err: err} 2605 } 2606 2607 restEncoder.SetHeader("Content-Type").String("application/json") 2608 2609 jsonEncoder := smithyjson.NewEncoder() 2610 if err := awsRestjson1_serializeOpDocumentDescribeWorldInput(input, jsonEncoder.Value); err != nil { 2611 return out, metadata, &smithy.SerializationError{Err: err} 2612 } 2613 2614 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2615 return out, metadata, &smithy.SerializationError{Err: err} 2616 } 2617 2618 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2619 return out, metadata, &smithy.SerializationError{Err: err} 2620 } 2621 in.Request = request 2622 2623 return next.HandleSerialize(ctx, in) 2624} 2625func awsRestjson1_serializeOpHttpBindingsDescribeWorldInput(v *DescribeWorldInput, encoder *httpbinding.Encoder) error { 2626 if v == nil { 2627 return fmt.Errorf("unsupported serialization of nil %T", v) 2628 } 2629 2630 return nil 2631} 2632 2633func awsRestjson1_serializeOpDocumentDescribeWorldInput(v *DescribeWorldInput, value smithyjson.Value) error { 2634 object := value.Object() 2635 defer object.Close() 2636 2637 if v.World != nil { 2638 ok := object.Key("world") 2639 ok.String(*v.World) 2640 } 2641 2642 return nil 2643} 2644 2645type awsRestjson1_serializeOpDescribeWorldExportJob struct { 2646} 2647 2648func (*awsRestjson1_serializeOpDescribeWorldExportJob) ID() string { 2649 return "OperationSerializer" 2650} 2651 2652func (m *awsRestjson1_serializeOpDescribeWorldExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2653 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2654) { 2655 request, ok := in.Request.(*smithyhttp.Request) 2656 if !ok { 2657 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2658 } 2659 2660 input, ok := in.Parameters.(*DescribeWorldExportJobInput) 2661 _ = input 2662 if !ok { 2663 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2664 } 2665 2666 opPath, opQuery := httpbinding.SplitURI("/describeWorldExportJob") 2667 request.URL.Path = opPath 2668 if len(request.URL.RawQuery) > 0 { 2669 request.URL.RawQuery = "&" + opQuery 2670 } else { 2671 request.URL.RawQuery = opQuery 2672 } 2673 2674 request.Method = "POST" 2675 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2676 if err != nil { 2677 return out, metadata, &smithy.SerializationError{Err: err} 2678 } 2679 2680 restEncoder.SetHeader("Content-Type").String("application/json") 2681 2682 jsonEncoder := smithyjson.NewEncoder() 2683 if err := awsRestjson1_serializeOpDocumentDescribeWorldExportJobInput(input, jsonEncoder.Value); err != nil { 2684 return out, metadata, &smithy.SerializationError{Err: err} 2685 } 2686 2687 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2688 return out, metadata, &smithy.SerializationError{Err: err} 2689 } 2690 2691 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2692 return out, metadata, &smithy.SerializationError{Err: err} 2693 } 2694 in.Request = request 2695 2696 return next.HandleSerialize(ctx, in) 2697} 2698func awsRestjson1_serializeOpHttpBindingsDescribeWorldExportJobInput(v *DescribeWorldExportJobInput, encoder *httpbinding.Encoder) error { 2699 if v == nil { 2700 return fmt.Errorf("unsupported serialization of nil %T", v) 2701 } 2702 2703 return nil 2704} 2705 2706func awsRestjson1_serializeOpDocumentDescribeWorldExportJobInput(v *DescribeWorldExportJobInput, value smithyjson.Value) error { 2707 object := value.Object() 2708 defer object.Close() 2709 2710 if v.Job != nil { 2711 ok := object.Key("job") 2712 ok.String(*v.Job) 2713 } 2714 2715 return nil 2716} 2717 2718type awsRestjson1_serializeOpDescribeWorldGenerationJob struct { 2719} 2720 2721func (*awsRestjson1_serializeOpDescribeWorldGenerationJob) ID() string { 2722 return "OperationSerializer" 2723} 2724 2725func (m *awsRestjson1_serializeOpDescribeWorldGenerationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2726 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2727) { 2728 request, ok := in.Request.(*smithyhttp.Request) 2729 if !ok { 2730 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2731 } 2732 2733 input, ok := in.Parameters.(*DescribeWorldGenerationJobInput) 2734 _ = input 2735 if !ok { 2736 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2737 } 2738 2739 opPath, opQuery := httpbinding.SplitURI("/describeWorldGenerationJob") 2740 request.URL.Path = opPath 2741 if len(request.URL.RawQuery) > 0 { 2742 request.URL.RawQuery = "&" + opQuery 2743 } else { 2744 request.URL.RawQuery = opQuery 2745 } 2746 2747 request.Method = "POST" 2748 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2749 if err != nil { 2750 return out, metadata, &smithy.SerializationError{Err: err} 2751 } 2752 2753 restEncoder.SetHeader("Content-Type").String("application/json") 2754 2755 jsonEncoder := smithyjson.NewEncoder() 2756 if err := awsRestjson1_serializeOpDocumentDescribeWorldGenerationJobInput(input, jsonEncoder.Value); err != nil { 2757 return out, metadata, &smithy.SerializationError{Err: err} 2758 } 2759 2760 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2761 return out, metadata, &smithy.SerializationError{Err: err} 2762 } 2763 2764 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2765 return out, metadata, &smithy.SerializationError{Err: err} 2766 } 2767 in.Request = request 2768 2769 return next.HandleSerialize(ctx, in) 2770} 2771func awsRestjson1_serializeOpHttpBindingsDescribeWorldGenerationJobInput(v *DescribeWorldGenerationJobInput, encoder *httpbinding.Encoder) error { 2772 if v == nil { 2773 return fmt.Errorf("unsupported serialization of nil %T", v) 2774 } 2775 2776 return nil 2777} 2778 2779func awsRestjson1_serializeOpDocumentDescribeWorldGenerationJobInput(v *DescribeWorldGenerationJobInput, value smithyjson.Value) error { 2780 object := value.Object() 2781 defer object.Close() 2782 2783 if v.Job != nil { 2784 ok := object.Key("job") 2785 ok.String(*v.Job) 2786 } 2787 2788 return nil 2789} 2790 2791type awsRestjson1_serializeOpDescribeWorldTemplate struct { 2792} 2793 2794func (*awsRestjson1_serializeOpDescribeWorldTemplate) ID() string { 2795 return "OperationSerializer" 2796} 2797 2798func (m *awsRestjson1_serializeOpDescribeWorldTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2799 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2800) { 2801 request, ok := in.Request.(*smithyhttp.Request) 2802 if !ok { 2803 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2804 } 2805 2806 input, ok := in.Parameters.(*DescribeWorldTemplateInput) 2807 _ = input 2808 if !ok { 2809 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2810 } 2811 2812 opPath, opQuery := httpbinding.SplitURI("/describeWorldTemplate") 2813 request.URL.Path = opPath 2814 if len(request.URL.RawQuery) > 0 { 2815 request.URL.RawQuery = "&" + opQuery 2816 } else { 2817 request.URL.RawQuery = opQuery 2818 } 2819 2820 request.Method = "POST" 2821 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2822 if err != nil { 2823 return out, metadata, &smithy.SerializationError{Err: err} 2824 } 2825 2826 restEncoder.SetHeader("Content-Type").String("application/json") 2827 2828 jsonEncoder := smithyjson.NewEncoder() 2829 if err := awsRestjson1_serializeOpDocumentDescribeWorldTemplateInput(input, jsonEncoder.Value); err != nil { 2830 return out, metadata, &smithy.SerializationError{Err: err} 2831 } 2832 2833 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2834 return out, metadata, &smithy.SerializationError{Err: err} 2835 } 2836 2837 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2838 return out, metadata, &smithy.SerializationError{Err: err} 2839 } 2840 in.Request = request 2841 2842 return next.HandleSerialize(ctx, in) 2843} 2844func awsRestjson1_serializeOpHttpBindingsDescribeWorldTemplateInput(v *DescribeWorldTemplateInput, encoder *httpbinding.Encoder) error { 2845 if v == nil { 2846 return fmt.Errorf("unsupported serialization of nil %T", v) 2847 } 2848 2849 return nil 2850} 2851 2852func awsRestjson1_serializeOpDocumentDescribeWorldTemplateInput(v *DescribeWorldTemplateInput, value smithyjson.Value) error { 2853 object := value.Object() 2854 defer object.Close() 2855 2856 if v.Template != nil { 2857 ok := object.Key("template") 2858 ok.String(*v.Template) 2859 } 2860 2861 return nil 2862} 2863 2864type awsRestjson1_serializeOpGetWorldTemplateBody struct { 2865} 2866 2867func (*awsRestjson1_serializeOpGetWorldTemplateBody) ID() string { 2868 return "OperationSerializer" 2869} 2870 2871func (m *awsRestjson1_serializeOpGetWorldTemplateBody) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2872 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2873) { 2874 request, ok := in.Request.(*smithyhttp.Request) 2875 if !ok { 2876 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2877 } 2878 2879 input, ok := in.Parameters.(*GetWorldTemplateBodyInput) 2880 _ = input 2881 if !ok { 2882 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2883 } 2884 2885 opPath, opQuery := httpbinding.SplitURI("/getWorldTemplateBody") 2886 request.URL.Path = opPath 2887 if len(request.URL.RawQuery) > 0 { 2888 request.URL.RawQuery = "&" + opQuery 2889 } else { 2890 request.URL.RawQuery = opQuery 2891 } 2892 2893 request.Method = "POST" 2894 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2895 if err != nil { 2896 return out, metadata, &smithy.SerializationError{Err: err} 2897 } 2898 2899 restEncoder.SetHeader("Content-Type").String("application/json") 2900 2901 jsonEncoder := smithyjson.NewEncoder() 2902 if err := awsRestjson1_serializeOpDocumentGetWorldTemplateBodyInput(input, jsonEncoder.Value); err != nil { 2903 return out, metadata, &smithy.SerializationError{Err: err} 2904 } 2905 2906 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2907 return out, metadata, &smithy.SerializationError{Err: err} 2908 } 2909 2910 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2911 return out, metadata, &smithy.SerializationError{Err: err} 2912 } 2913 in.Request = request 2914 2915 return next.HandleSerialize(ctx, in) 2916} 2917func awsRestjson1_serializeOpHttpBindingsGetWorldTemplateBodyInput(v *GetWorldTemplateBodyInput, encoder *httpbinding.Encoder) error { 2918 if v == nil { 2919 return fmt.Errorf("unsupported serialization of nil %T", v) 2920 } 2921 2922 return nil 2923} 2924 2925func awsRestjson1_serializeOpDocumentGetWorldTemplateBodyInput(v *GetWorldTemplateBodyInput, value smithyjson.Value) error { 2926 object := value.Object() 2927 defer object.Close() 2928 2929 if v.GenerationJob != nil { 2930 ok := object.Key("generationJob") 2931 ok.String(*v.GenerationJob) 2932 } 2933 2934 if v.Template != nil { 2935 ok := object.Key("template") 2936 ok.String(*v.Template) 2937 } 2938 2939 return nil 2940} 2941 2942type awsRestjson1_serializeOpListDeploymentJobs struct { 2943} 2944 2945func (*awsRestjson1_serializeOpListDeploymentJobs) ID() string { 2946 return "OperationSerializer" 2947} 2948 2949func (m *awsRestjson1_serializeOpListDeploymentJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2950 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2951) { 2952 request, ok := in.Request.(*smithyhttp.Request) 2953 if !ok { 2954 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2955 } 2956 2957 input, ok := in.Parameters.(*ListDeploymentJobsInput) 2958 _ = input 2959 if !ok { 2960 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2961 } 2962 2963 opPath, opQuery := httpbinding.SplitURI("/listDeploymentJobs") 2964 request.URL.Path = opPath 2965 if len(request.URL.RawQuery) > 0 { 2966 request.URL.RawQuery = "&" + opQuery 2967 } else { 2968 request.URL.RawQuery = opQuery 2969 } 2970 2971 request.Method = "POST" 2972 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2973 if err != nil { 2974 return out, metadata, &smithy.SerializationError{Err: err} 2975 } 2976 2977 restEncoder.SetHeader("Content-Type").String("application/json") 2978 2979 jsonEncoder := smithyjson.NewEncoder() 2980 if err := awsRestjson1_serializeOpDocumentListDeploymentJobsInput(input, jsonEncoder.Value); err != nil { 2981 return out, metadata, &smithy.SerializationError{Err: err} 2982 } 2983 2984 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2985 return out, metadata, &smithy.SerializationError{Err: err} 2986 } 2987 2988 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2989 return out, metadata, &smithy.SerializationError{Err: err} 2990 } 2991 in.Request = request 2992 2993 return next.HandleSerialize(ctx, in) 2994} 2995func awsRestjson1_serializeOpHttpBindingsListDeploymentJobsInput(v *ListDeploymentJobsInput, encoder *httpbinding.Encoder) error { 2996 if v == nil { 2997 return fmt.Errorf("unsupported serialization of nil %T", v) 2998 } 2999 3000 return nil 3001} 3002 3003func awsRestjson1_serializeOpDocumentListDeploymentJobsInput(v *ListDeploymentJobsInput, value smithyjson.Value) error { 3004 object := value.Object() 3005 defer object.Close() 3006 3007 if v.Filters != nil { 3008 ok := object.Key("filters") 3009 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3010 return err 3011 } 3012 } 3013 3014 if v.MaxResults != nil { 3015 ok := object.Key("maxResults") 3016 ok.Integer(*v.MaxResults) 3017 } 3018 3019 if v.NextToken != nil { 3020 ok := object.Key("nextToken") 3021 ok.String(*v.NextToken) 3022 } 3023 3024 return nil 3025} 3026 3027type awsRestjson1_serializeOpListFleets struct { 3028} 3029 3030func (*awsRestjson1_serializeOpListFleets) ID() string { 3031 return "OperationSerializer" 3032} 3033 3034func (m *awsRestjson1_serializeOpListFleets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3035 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3036) { 3037 request, ok := in.Request.(*smithyhttp.Request) 3038 if !ok { 3039 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3040 } 3041 3042 input, ok := in.Parameters.(*ListFleetsInput) 3043 _ = input 3044 if !ok { 3045 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3046 } 3047 3048 opPath, opQuery := httpbinding.SplitURI("/listFleets") 3049 request.URL.Path = opPath 3050 if len(request.URL.RawQuery) > 0 { 3051 request.URL.RawQuery = "&" + opQuery 3052 } else { 3053 request.URL.RawQuery = opQuery 3054 } 3055 3056 request.Method = "POST" 3057 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3058 if err != nil { 3059 return out, metadata, &smithy.SerializationError{Err: err} 3060 } 3061 3062 restEncoder.SetHeader("Content-Type").String("application/json") 3063 3064 jsonEncoder := smithyjson.NewEncoder() 3065 if err := awsRestjson1_serializeOpDocumentListFleetsInput(input, jsonEncoder.Value); err != nil { 3066 return out, metadata, &smithy.SerializationError{Err: err} 3067 } 3068 3069 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3070 return out, metadata, &smithy.SerializationError{Err: err} 3071 } 3072 3073 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3074 return out, metadata, &smithy.SerializationError{Err: err} 3075 } 3076 in.Request = request 3077 3078 return next.HandleSerialize(ctx, in) 3079} 3080func awsRestjson1_serializeOpHttpBindingsListFleetsInput(v *ListFleetsInput, encoder *httpbinding.Encoder) error { 3081 if v == nil { 3082 return fmt.Errorf("unsupported serialization of nil %T", v) 3083 } 3084 3085 return nil 3086} 3087 3088func awsRestjson1_serializeOpDocumentListFleetsInput(v *ListFleetsInput, value smithyjson.Value) error { 3089 object := value.Object() 3090 defer object.Close() 3091 3092 if v.Filters != nil { 3093 ok := object.Key("filters") 3094 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3095 return err 3096 } 3097 } 3098 3099 if v.MaxResults != nil { 3100 ok := object.Key("maxResults") 3101 ok.Integer(*v.MaxResults) 3102 } 3103 3104 if v.NextToken != nil { 3105 ok := object.Key("nextToken") 3106 ok.String(*v.NextToken) 3107 } 3108 3109 return nil 3110} 3111 3112type awsRestjson1_serializeOpListRobotApplications struct { 3113} 3114 3115func (*awsRestjson1_serializeOpListRobotApplications) ID() string { 3116 return "OperationSerializer" 3117} 3118 3119func (m *awsRestjson1_serializeOpListRobotApplications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3120 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3121) { 3122 request, ok := in.Request.(*smithyhttp.Request) 3123 if !ok { 3124 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3125 } 3126 3127 input, ok := in.Parameters.(*ListRobotApplicationsInput) 3128 _ = input 3129 if !ok { 3130 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3131 } 3132 3133 opPath, opQuery := httpbinding.SplitURI("/listRobotApplications") 3134 request.URL.Path = opPath 3135 if len(request.URL.RawQuery) > 0 { 3136 request.URL.RawQuery = "&" + opQuery 3137 } else { 3138 request.URL.RawQuery = opQuery 3139 } 3140 3141 request.Method = "POST" 3142 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3143 if err != nil { 3144 return out, metadata, &smithy.SerializationError{Err: err} 3145 } 3146 3147 restEncoder.SetHeader("Content-Type").String("application/json") 3148 3149 jsonEncoder := smithyjson.NewEncoder() 3150 if err := awsRestjson1_serializeOpDocumentListRobotApplicationsInput(input, jsonEncoder.Value); err != nil { 3151 return out, metadata, &smithy.SerializationError{Err: err} 3152 } 3153 3154 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3155 return out, metadata, &smithy.SerializationError{Err: err} 3156 } 3157 3158 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3159 return out, metadata, &smithy.SerializationError{Err: err} 3160 } 3161 in.Request = request 3162 3163 return next.HandleSerialize(ctx, in) 3164} 3165func awsRestjson1_serializeOpHttpBindingsListRobotApplicationsInput(v *ListRobotApplicationsInput, encoder *httpbinding.Encoder) error { 3166 if v == nil { 3167 return fmt.Errorf("unsupported serialization of nil %T", v) 3168 } 3169 3170 return nil 3171} 3172 3173func awsRestjson1_serializeOpDocumentListRobotApplicationsInput(v *ListRobotApplicationsInput, value smithyjson.Value) error { 3174 object := value.Object() 3175 defer object.Close() 3176 3177 if v.Filters != nil { 3178 ok := object.Key("filters") 3179 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3180 return err 3181 } 3182 } 3183 3184 if v.MaxResults != nil { 3185 ok := object.Key("maxResults") 3186 ok.Integer(*v.MaxResults) 3187 } 3188 3189 if v.NextToken != nil { 3190 ok := object.Key("nextToken") 3191 ok.String(*v.NextToken) 3192 } 3193 3194 if v.VersionQualifier != nil { 3195 ok := object.Key("versionQualifier") 3196 ok.String(*v.VersionQualifier) 3197 } 3198 3199 return nil 3200} 3201 3202type awsRestjson1_serializeOpListRobots struct { 3203} 3204 3205func (*awsRestjson1_serializeOpListRobots) ID() string { 3206 return "OperationSerializer" 3207} 3208 3209func (m *awsRestjson1_serializeOpListRobots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3210 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3211) { 3212 request, ok := in.Request.(*smithyhttp.Request) 3213 if !ok { 3214 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3215 } 3216 3217 input, ok := in.Parameters.(*ListRobotsInput) 3218 _ = input 3219 if !ok { 3220 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3221 } 3222 3223 opPath, opQuery := httpbinding.SplitURI("/listRobots") 3224 request.URL.Path = opPath 3225 if len(request.URL.RawQuery) > 0 { 3226 request.URL.RawQuery = "&" + opQuery 3227 } else { 3228 request.URL.RawQuery = opQuery 3229 } 3230 3231 request.Method = "POST" 3232 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3233 if err != nil { 3234 return out, metadata, &smithy.SerializationError{Err: err} 3235 } 3236 3237 restEncoder.SetHeader("Content-Type").String("application/json") 3238 3239 jsonEncoder := smithyjson.NewEncoder() 3240 if err := awsRestjson1_serializeOpDocumentListRobotsInput(input, jsonEncoder.Value); err != nil { 3241 return out, metadata, &smithy.SerializationError{Err: err} 3242 } 3243 3244 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3245 return out, metadata, &smithy.SerializationError{Err: err} 3246 } 3247 3248 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3249 return out, metadata, &smithy.SerializationError{Err: err} 3250 } 3251 in.Request = request 3252 3253 return next.HandleSerialize(ctx, in) 3254} 3255func awsRestjson1_serializeOpHttpBindingsListRobotsInput(v *ListRobotsInput, encoder *httpbinding.Encoder) error { 3256 if v == nil { 3257 return fmt.Errorf("unsupported serialization of nil %T", v) 3258 } 3259 3260 return nil 3261} 3262 3263func awsRestjson1_serializeOpDocumentListRobotsInput(v *ListRobotsInput, value smithyjson.Value) error { 3264 object := value.Object() 3265 defer object.Close() 3266 3267 if v.Filters != nil { 3268 ok := object.Key("filters") 3269 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3270 return err 3271 } 3272 } 3273 3274 if v.MaxResults != nil { 3275 ok := object.Key("maxResults") 3276 ok.Integer(*v.MaxResults) 3277 } 3278 3279 if v.NextToken != nil { 3280 ok := object.Key("nextToken") 3281 ok.String(*v.NextToken) 3282 } 3283 3284 return nil 3285} 3286 3287type awsRestjson1_serializeOpListSimulationApplications struct { 3288} 3289 3290func (*awsRestjson1_serializeOpListSimulationApplications) ID() string { 3291 return "OperationSerializer" 3292} 3293 3294func (m *awsRestjson1_serializeOpListSimulationApplications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3295 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3296) { 3297 request, ok := in.Request.(*smithyhttp.Request) 3298 if !ok { 3299 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3300 } 3301 3302 input, ok := in.Parameters.(*ListSimulationApplicationsInput) 3303 _ = input 3304 if !ok { 3305 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3306 } 3307 3308 opPath, opQuery := httpbinding.SplitURI("/listSimulationApplications") 3309 request.URL.Path = opPath 3310 if len(request.URL.RawQuery) > 0 { 3311 request.URL.RawQuery = "&" + opQuery 3312 } else { 3313 request.URL.RawQuery = opQuery 3314 } 3315 3316 request.Method = "POST" 3317 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3318 if err != nil { 3319 return out, metadata, &smithy.SerializationError{Err: err} 3320 } 3321 3322 restEncoder.SetHeader("Content-Type").String("application/json") 3323 3324 jsonEncoder := smithyjson.NewEncoder() 3325 if err := awsRestjson1_serializeOpDocumentListSimulationApplicationsInput(input, jsonEncoder.Value); err != nil { 3326 return out, metadata, &smithy.SerializationError{Err: err} 3327 } 3328 3329 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3330 return out, metadata, &smithy.SerializationError{Err: err} 3331 } 3332 3333 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3334 return out, metadata, &smithy.SerializationError{Err: err} 3335 } 3336 in.Request = request 3337 3338 return next.HandleSerialize(ctx, in) 3339} 3340func awsRestjson1_serializeOpHttpBindingsListSimulationApplicationsInput(v *ListSimulationApplicationsInput, encoder *httpbinding.Encoder) error { 3341 if v == nil { 3342 return fmt.Errorf("unsupported serialization of nil %T", v) 3343 } 3344 3345 return nil 3346} 3347 3348func awsRestjson1_serializeOpDocumentListSimulationApplicationsInput(v *ListSimulationApplicationsInput, value smithyjson.Value) error { 3349 object := value.Object() 3350 defer object.Close() 3351 3352 if v.Filters != nil { 3353 ok := object.Key("filters") 3354 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3355 return err 3356 } 3357 } 3358 3359 if v.MaxResults != nil { 3360 ok := object.Key("maxResults") 3361 ok.Integer(*v.MaxResults) 3362 } 3363 3364 if v.NextToken != nil { 3365 ok := object.Key("nextToken") 3366 ok.String(*v.NextToken) 3367 } 3368 3369 if v.VersionQualifier != nil { 3370 ok := object.Key("versionQualifier") 3371 ok.String(*v.VersionQualifier) 3372 } 3373 3374 return nil 3375} 3376 3377type awsRestjson1_serializeOpListSimulationJobBatches struct { 3378} 3379 3380func (*awsRestjson1_serializeOpListSimulationJobBatches) ID() string { 3381 return "OperationSerializer" 3382} 3383 3384func (m *awsRestjson1_serializeOpListSimulationJobBatches) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3385 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3386) { 3387 request, ok := in.Request.(*smithyhttp.Request) 3388 if !ok { 3389 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3390 } 3391 3392 input, ok := in.Parameters.(*ListSimulationJobBatchesInput) 3393 _ = input 3394 if !ok { 3395 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3396 } 3397 3398 opPath, opQuery := httpbinding.SplitURI("/listSimulationJobBatches") 3399 request.URL.Path = opPath 3400 if len(request.URL.RawQuery) > 0 { 3401 request.URL.RawQuery = "&" + opQuery 3402 } else { 3403 request.URL.RawQuery = opQuery 3404 } 3405 3406 request.Method = "POST" 3407 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3408 if err != nil { 3409 return out, metadata, &smithy.SerializationError{Err: err} 3410 } 3411 3412 restEncoder.SetHeader("Content-Type").String("application/json") 3413 3414 jsonEncoder := smithyjson.NewEncoder() 3415 if err := awsRestjson1_serializeOpDocumentListSimulationJobBatchesInput(input, jsonEncoder.Value); err != nil { 3416 return out, metadata, &smithy.SerializationError{Err: err} 3417 } 3418 3419 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3420 return out, metadata, &smithy.SerializationError{Err: err} 3421 } 3422 3423 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3424 return out, metadata, &smithy.SerializationError{Err: err} 3425 } 3426 in.Request = request 3427 3428 return next.HandleSerialize(ctx, in) 3429} 3430func awsRestjson1_serializeOpHttpBindingsListSimulationJobBatchesInput(v *ListSimulationJobBatchesInput, encoder *httpbinding.Encoder) error { 3431 if v == nil { 3432 return fmt.Errorf("unsupported serialization of nil %T", v) 3433 } 3434 3435 return nil 3436} 3437 3438func awsRestjson1_serializeOpDocumentListSimulationJobBatchesInput(v *ListSimulationJobBatchesInput, value smithyjson.Value) error { 3439 object := value.Object() 3440 defer object.Close() 3441 3442 if v.Filters != nil { 3443 ok := object.Key("filters") 3444 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3445 return err 3446 } 3447 } 3448 3449 if v.MaxResults != nil { 3450 ok := object.Key("maxResults") 3451 ok.Integer(*v.MaxResults) 3452 } 3453 3454 if v.NextToken != nil { 3455 ok := object.Key("nextToken") 3456 ok.String(*v.NextToken) 3457 } 3458 3459 return nil 3460} 3461 3462type awsRestjson1_serializeOpListSimulationJobs struct { 3463} 3464 3465func (*awsRestjson1_serializeOpListSimulationJobs) ID() string { 3466 return "OperationSerializer" 3467} 3468 3469func (m *awsRestjson1_serializeOpListSimulationJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3470 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3471) { 3472 request, ok := in.Request.(*smithyhttp.Request) 3473 if !ok { 3474 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3475 } 3476 3477 input, ok := in.Parameters.(*ListSimulationJobsInput) 3478 _ = input 3479 if !ok { 3480 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3481 } 3482 3483 opPath, opQuery := httpbinding.SplitURI("/listSimulationJobs") 3484 request.URL.Path = opPath 3485 if len(request.URL.RawQuery) > 0 { 3486 request.URL.RawQuery = "&" + opQuery 3487 } else { 3488 request.URL.RawQuery = opQuery 3489 } 3490 3491 request.Method = "POST" 3492 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3493 if err != nil { 3494 return out, metadata, &smithy.SerializationError{Err: err} 3495 } 3496 3497 restEncoder.SetHeader("Content-Type").String("application/json") 3498 3499 jsonEncoder := smithyjson.NewEncoder() 3500 if err := awsRestjson1_serializeOpDocumentListSimulationJobsInput(input, jsonEncoder.Value); err != nil { 3501 return out, metadata, &smithy.SerializationError{Err: err} 3502 } 3503 3504 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3505 return out, metadata, &smithy.SerializationError{Err: err} 3506 } 3507 3508 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3509 return out, metadata, &smithy.SerializationError{Err: err} 3510 } 3511 in.Request = request 3512 3513 return next.HandleSerialize(ctx, in) 3514} 3515func awsRestjson1_serializeOpHttpBindingsListSimulationJobsInput(v *ListSimulationJobsInput, encoder *httpbinding.Encoder) error { 3516 if v == nil { 3517 return fmt.Errorf("unsupported serialization of nil %T", v) 3518 } 3519 3520 return nil 3521} 3522 3523func awsRestjson1_serializeOpDocumentListSimulationJobsInput(v *ListSimulationJobsInput, value smithyjson.Value) error { 3524 object := value.Object() 3525 defer object.Close() 3526 3527 if v.Filters != nil { 3528 ok := object.Key("filters") 3529 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3530 return err 3531 } 3532 } 3533 3534 if v.MaxResults != nil { 3535 ok := object.Key("maxResults") 3536 ok.Integer(*v.MaxResults) 3537 } 3538 3539 if v.NextToken != nil { 3540 ok := object.Key("nextToken") 3541 ok.String(*v.NextToken) 3542 } 3543 3544 return nil 3545} 3546 3547type awsRestjson1_serializeOpListTagsForResource struct { 3548} 3549 3550func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 3551 return "OperationSerializer" 3552} 3553 3554func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3555 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3556) { 3557 request, ok := in.Request.(*smithyhttp.Request) 3558 if !ok { 3559 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3560 } 3561 3562 input, ok := in.Parameters.(*ListTagsForResourceInput) 3563 _ = input 3564 if !ok { 3565 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3566 } 3567 3568 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 3569 request.URL.Path = opPath 3570 if len(request.URL.RawQuery) > 0 { 3571 request.URL.RawQuery = "&" + opQuery 3572 } else { 3573 request.URL.RawQuery = opQuery 3574 } 3575 3576 request.Method = "GET" 3577 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3578 if err != nil { 3579 return out, metadata, &smithy.SerializationError{Err: err} 3580 } 3581 3582 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 3583 return out, metadata, &smithy.SerializationError{Err: err} 3584 } 3585 3586 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3587 return out, metadata, &smithy.SerializationError{Err: err} 3588 } 3589 in.Request = request 3590 3591 return next.HandleSerialize(ctx, in) 3592} 3593func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 3594 if v == nil { 3595 return fmt.Errorf("unsupported serialization of nil %T", v) 3596 } 3597 3598 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 3599 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 3600 } 3601 if v.ResourceArn != nil { 3602 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 3603 return err 3604 } 3605 } 3606 3607 return nil 3608} 3609 3610type awsRestjson1_serializeOpListWorldExportJobs struct { 3611} 3612 3613func (*awsRestjson1_serializeOpListWorldExportJobs) ID() string { 3614 return "OperationSerializer" 3615} 3616 3617func (m *awsRestjson1_serializeOpListWorldExportJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3618 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3619) { 3620 request, ok := in.Request.(*smithyhttp.Request) 3621 if !ok { 3622 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3623 } 3624 3625 input, ok := in.Parameters.(*ListWorldExportJobsInput) 3626 _ = input 3627 if !ok { 3628 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3629 } 3630 3631 opPath, opQuery := httpbinding.SplitURI("/listWorldExportJobs") 3632 request.URL.Path = opPath 3633 if len(request.URL.RawQuery) > 0 { 3634 request.URL.RawQuery = "&" + opQuery 3635 } else { 3636 request.URL.RawQuery = opQuery 3637 } 3638 3639 request.Method = "POST" 3640 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3641 if err != nil { 3642 return out, metadata, &smithy.SerializationError{Err: err} 3643 } 3644 3645 restEncoder.SetHeader("Content-Type").String("application/json") 3646 3647 jsonEncoder := smithyjson.NewEncoder() 3648 if err := awsRestjson1_serializeOpDocumentListWorldExportJobsInput(input, jsonEncoder.Value); err != nil { 3649 return out, metadata, &smithy.SerializationError{Err: err} 3650 } 3651 3652 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3653 return out, metadata, &smithy.SerializationError{Err: err} 3654 } 3655 3656 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3657 return out, metadata, &smithy.SerializationError{Err: err} 3658 } 3659 in.Request = request 3660 3661 return next.HandleSerialize(ctx, in) 3662} 3663func awsRestjson1_serializeOpHttpBindingsListWorldExportJobsInput(v *ListWorldExportJobsInput, encoder *httpbinding.Encoder) error { 3664 if v == nil { 3665 return fmt.Errorf("unsupported serialization of nil %T", v) 3666 } 3667 3668 return nil 3669} 3670 3671func awsRestjson1_serializeOpDocumentListWorldExportJobsInput(v *ListWorldExportJobsInput, value smithyjson.Value) error { 3672 object := value.Object() 3673 defer object.Close() 3674 3675 if v.Filters != nil { 3676 ok := object.Key("filters") 3677 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3678 return err 3679 } 3680 } 3681 3682 if v.MaxResults != nil { 3683 ok := object.Key("maxResults") 3684 ok.Integer(*v.MaxResults) 3685 } 3686 3687 if v.NextToken != nil { 3688 ok := object.Key("nextToken") 3689 ok.String(*v.NextToken) 3690 } 3691 3692 return nil 3693} 3694 3695type awsRestjson1_serializeOpListWorldGenerationJobs struct { 3696} 3697 3698func (*awsRestjson1_serializeOpListWorldGenerationJobs) ID() string { 3699 return "OperationSerializer" 3700} 3701 3702func (m *awsRestjson1_serializeOpListWorldGenerationJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3703 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3704) { 3705 request, ok := in.Request.(*smithyhttp.Request) 3706 if !ok { 3707 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3708 } 3709 3710 input, ok := in.Parameters.(*ListWorldGenerationJobsInput) 3711 _ = input 3712 if !ok { 3713 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3714 } 3715 3716 opPath, opQuery := httpbinding.SplitURI("/listWorldGenerationJobs") 3717 request.URL.Path = opPath 3718 if len(request.URL.RawQuery) > 0 { 3719 request.URL.RawQuery = "&" + opQuery 3720 } else { 3721 request.URL.RawQuery = opQuery 3722 } 3723 3724 request.Method = "POST" 3725 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3726 if err != nil { 3727 return out, metadata, &smithy.SerializationError{Err: err} 3728 } 3729 3730 restEncoder.SetHeader("Content-Type").String("application/json") 3731 3732 jsonEncoder := smithyjson.NewEncoder() 3733 if err := awsRestjson1_serializeOpDocumentListWorldGenerationJobsInput(input, jsonEncoder.Value); err != nil { 3734 return out, metadata, &smithy.SerializationError{Err: err} 3735 } 3736 3737 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3738 return out, metadata, &smithy.SerializationError{Err: err} 3739 } 3740 3741 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3742 return out, metadata, &smithy.SerializationError{Err: err} 3743 } 3744 in.Request = request 3745 3746 return next.HandleSerialize(ctx, in) 3747} 3748func awsRestjson1_serializeOpHttpBindingsListWorldGenerationJobsInput(v *ListWorldGenerationJobsInput, encoder *httpbinding.Encoder) error { 3749 if v == nil { 3750 return fmt.Errorf("unsupported serialization of nil %T", v) 3751 } 3752 3753 return nil 3754} 3755 3756func awsRestjson1_serializeOpDocumentListWorldGenerationJobsInput(v *ListWorldGenerationJobsInput, value smithyjson.Value) error { 3757 object := value.Object() 3758 defer object.Close() 3759 3760 if v.Filters != nil { 3761 ok := object.Key("filters") 3762 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3763 return err 3764 } 3765 } 3766 3767 if v.MaxResults != nil { 3768 ok := object.Key("maxResults") 3769 ok.Integer(*v.MaxResults) 3770 } 3771 3772 if v.NextToken != nil { 3773 ok := object.Key("nextToken") 3774 ok.String(*v.NextToken) 3775 } 3776 3777 return nil 3778} 3779 3780type awsRestjson1_serializeOpListWorlds struct { 3781} 3782 3783func (*awsRestjson1_serializeOpListWorlds) ID() string { 3784 return "OperationSerializer" 3785} 3786 3787func (m *awsRestjson1_serializeOpListWorlds) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3788 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3789) { 3790 request, ok := in.Request.(*smithyhttp.Request) 3791 if !ok { 3792 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3793 } 3794 3795 input, ok := in.Parameters.(*ListWorldsInput) 3796 _ = input 3797 if !ok { 3798 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3799 } 3800 3801 opPath, opQuery := httpbinding.SplitURI("/listWorlds") 3802 request.URL.Path = opPath 3803 if len(request.URL.RawQuery) > 0 { 3804 request.URL.RawQuery = "&" + opQuery 3805 } else { 3806 request.URL.RawQuery = opQuery 3807 } 3808 3809 request.Method = "POST" 3810 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3811 if err != nil { 3812 return out, metadata, &smithy.SerializationError{Err: err} 3813 } 3814 3815 restEncoder.SetHeader("Content-Type").String("application/json") 3816 3817 jsonEncoder := smithyjson.NewEncoder() 3818 if err := awsRestjson1_serializeOpDocumentListWorldsInput(input, jsonEncoder.Value); err != nil { 3819 return out, metadata, &smithy.SerializationError{Err: err} 3820 } 3821 3822 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3823 return out, metadata, &smithy.SerializationError{Err: err} 3824 } 3825 3826 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3827 return out, metadata, &smithy.SerializationError{Err: err} 3828 } 3829 in.Request = request 3830 3831 return next.HandleSerialize(ctx, in) 3832} 3833func awsRestjson1_serializeOpHttpBindingsListWorldsInput(v *ListWorldsInput, encoder *httpbinding.Encoder) error { 3834 if v == nil { 3835 return fmt.Errorf("unsupported serialization of nil %T", v) 3836 } 3837 3838 return nil 3839} 3840 3841func awsRestjson1_serializeOpDocumentListWorldsInput(v *ListWorldsInput, value smithyjson.Value) error { 3842 object := value.Object() 3843 defer object.Close() 3844 3845 if v.Filters != nil { 3846 ok := object.Key("filters") 3847 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3848 return err 3849 } 3850 } 3851 3852 if v.MaxResults != nil { 3853 ok := object.Key("maxResults") 3854 ok.Integer(*v.MaxResults) 3855 } 3856 3857 if v.NextToken != nil { 3858 ok := object.Key("nextToken") 3859 ok.String(*v.NextToken) 3860 } 3861 3862 return nil 3863} 3864 3865type awsRestjson1_serializeOpListWorldTemplates struct { 3866} 3867 3868func (*awsRestjson1_serializeOpListWorldTemplates) ID() string { 3869 return "OperationSerializer" 3870} 3871 3872func (m *awsRestjson1_serializeOpListWorldTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3873 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3874) { 3875 request, ok := in.Request.(*smithyhttp.Request) 3876 if !ok { 3877 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3878 } 3879 3880 input, ok := in.Parameters.(*ListWorldTemplatesInput) 3881 _ = input 3882 if !ok { 3883 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3884 } 3885 3886 opPath, opQuery := httpbinding.SplitURI("/listWorldTemplates") 3887 request.URL.Path = opPath 3888 if len(request.URL.RawQuery) > 0 { 3889 request.URL.RawQuery = "&" + opQuery 3890 } else { 3891 request.URL.RawQuery = opQuery 3892 } 3893 3894 request.Method = "POST" 3895 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3896 if err != nil { 3897 return out, metadata, &smithy.SerializationError{Err: err} 3898 } 3899 3900 restEncoder.SetHeader("Content-Type").String("application/json") 3901 3902 jsonEncoder := smithyjson.NewEncoder() 3903 if err := awsRestjson1_serializeOpDocumentListWorldTemplatesInput(input, jsonEncoder.Value); err != nil { 3904 return out, metadata, &smithy.SerializationError{Err: err} 3905 } 3906 3907 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3908 return out, metadata, &smithy.SerializationError{Err: err} 3909 } 3910 3911 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3912 return out, metadata, &smithy.SerializationError{Err: err} 3913 } 3914 in.Request = request 3915 3916 return next.HandleSerialize(ctx, in) 3917} 3918func awsRestjson1_serializeOpHttpBindingsListWorldTemplatesInput(v *ListWorldTemplatesInput, encoder *httpbinding.Encoder) error { 3919 if v == nil { 3920 return fmt.Errorf("unsupported serialization of nil %T", v) 3921 } 3922 3923 return nil 3924} 3925 3926func awsRestjson1_serializeOpDocumentListWorldTemplatesInput(v *ListWorldTemplatesInput, value smithyjson.Value) error { 3927 object := value.Object() 3928 defer object.Close() 3929 3930 if v.MaxResults != nil { 3931 ok := object.Key("maxResults") 3932 ok.Integer(*v.MaxResults) 3933 } 3934 3935 if v.NextToken != nil { 3936 ok := object.Key("nextToken") 3937 ok.String(*v.NextToken) 3938 } 3939 3940 return nil 3941} 3942 3943type awsRestjson1_serializeOpRegisterRobot struct { 3944} 3945 3946func (*awsRestjson1_serializeOpRegisterRobot) ID() string { 3947 return "OperationSerializer" 3948} 3949 3950func (m *awsRestjson1_serializeOpRegisterRobot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3951 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3952) { 3953 request, ok := in.Request.(*smithyhttp.Request) 3954 if !ok { 3955 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3956 } 3957 3958 input, ok := in.Parameters.(*RegisterRobotInput) 3959 _ = input 3960 if !ok { 3961 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3962 } 3963 3964 opPath, opQuery := httpbinding.SplitURI("/registerRobot") 3965 request.URL.Path = opPath 3966 if len(request.URL.RawQuery) > 0 { 3967 request.URL.RawQuery = "&" + opQuery 3968 } else { 3969 request.URL.RawQuery = opQuery 3970 } 3971 3972 request.Method = "POST" 3973 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3974 if err != nil { 3975 return out, metadata, &smithy.SerializationError{Err: err} 3976 } 3977 3978 restEncoder.SetHeader("Content-Type").String("application/json") 3979 3980 jsonEncoder := smithyjson.NewEncoder() 3981 if err := awsRestjson1_serializeOpDocumentRegisterRobotInput(input, jsonEncoder.Value); err != nil { 3982 return out, metadata, &smithy.SerializationError{Err: err} 3983 } 3984 3985 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3986 return out, metadata, &smithy.SerializationError{Err: err} 3987 } 3988 3989 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3990 return out, metadata, &smithy.SerializationError{Err: err} 3991 } 3992 in.Request = request 3993 3994 return next.HandleSerialize(ctx, in) 3995} 3996func awsRestjson1_serializeOpHttpBindingsRegisterRobotInput(v *RegisterRobotInput, encoder *httpbinding.Encoder) error { 3997 if v == nil { 3998 return fmt.Errorf("unsupported serialization of nil %T", v) 3999 } 4000 4001 return nil 4002} 4003 4004func awsRestjson1_serializeOpDocumentRegisterRobotInput(v *RegisterRobotInput, value smithyjson.Value) error { 4005 object := value.Object() 4006 defer object.Close() 4007 4008 if v.Fleet != nil { 4009 ok := object.Key("fleet") 4010 ok.String(*v.Fleet) 4011 } 4012 4013 if v.Robot != nil { 4014 ok := object.Key("robot") 4015 ok.String(*v.Robot) 4016 } 4017 4018 return nil 4019} 4020 4021type awsRestjson1_serializeOpRestartSimulationJob struct { 4022} 4023 4024func (*awsRestjson1_serializeOpRestartSimulationJob) ID() string { 4025 return "OperationSerializer" 4026} 4027 4028func (m *awsRestjson1_serializeOpRestartSimulationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4029 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4030) { 4031 request, ok := in.Request.(*smithyhttp.Request) 4032 if !ok { 4033 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4034 } 4035 4036 input, ok := in.Parameters.(*RestartSimulationJobInput) 4037 _ = input 4038 if !ok { 4039 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4040 } 4041 4042 opPath, opQuery := httpbinding.SplitURI("/restartSimulationJob") 4043 request.URL.Path = opPath 4044 if len(request.URL.RawQuery) > 0 { 4045 request.URL.RawQuery = "&" + opQuery 4046 } else { 4047 request.URL.RawQuery = opQuery 4048 } 4049 4050 request.Method = "POST" 4051 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4052 if err != nil { 4053 return out, metadata, &smithy.SerializationError{Err: err} 4054 } 4055 4056 restEncoder.SetHeader("Content-Type").String("application/json") 4057 4058 jsonEncoder := smithyjson.NewEncoder() 4059 if err := awsRestjson1_serializeOpDocumentRestartSimulationJobInput(input, jsonEncoder.Value); err != nil { 4060 return out, metadata, &smithy.SerializationError{Err: err} 4061 } 4062 4063 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4064 return out, metadata, &smithy.SerializationError{Err: err} 4065 } 4066 4067 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4068 return out, metadata, &smithy.SerializationError{Err: err} 4069 } 4070 in.Request = request 4071 4072 return next.HandleSerialize(ctx, in) 4073} 4074func awsRestjson1_serializeOpHttpBindingsRestartSimulationJobInput(v *RestartSimulationJobInput, encoder *httpbinding.Encoder) error { 4075 if v == nil { 4076 return fmt.Errorf("unsupported serialization of nil %T", v) 4077 } 4078 4079 return nil 4080} 4081 4082func awsRestjson1_serializeOpDocumentRestartSimulationJobInput(v *RestartSimulationJobInput, value smithyjson.Value) error { 4083 object := value.Object() 4084 defer object.Close() 4085 4086 if v.Job != nil { 4087 ok := object.Key("job") 4088 ok.String(*v.Job) 4089 } 4090 4091 return nil 4092} 4093 4094type awsRestjson1_serializeOpStartSimulationJobBatch struct { 4095} 4096 4097func (*awsRestjson1_serializeOpStartSimulationJobBatch) ID() string { 4098 return "OperationSerializer" 4099} 4100 4101func (m *awsRestjson1_serializeOpStartSimulationJobBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4102 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4103) { 4104 request, ok := in.Request.(*smithyhttp.Request) 4105 if !ok { 4106 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4107 } 4108 4109 input, ok := in.Parameters.(*StartSimulationJobBatchInput) 4110 _ = input 4111 if !ok { 4112 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4113 } 4114 4115 opPath, opQuery := httpbinding.SplitURI("/startSimulationJobBatch") 4116 request.URL.Path = opPath 4117 if len(request.URL.RawQuery) > 0 { 4118 request.URL.RawQuery = "&" + opQuery 4119 } else { 4120 request.URL.RawQuery = opQuery 4121 } 4122 4123 request.Method = "POST" 4124 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4125 if err != nil { 4126 return out, metadata, &smithy.SerializationError{Err: err} 4127 } 4128 4129 restEncoder.SetHeader("Content-Type").String("application/json") 4130 4131 jsonEncoder := smithyjson.NewEncoder() 4132 if err := awsRestjson1_serializeOpDocumentStartSimulationJobBatchInput(input, jsonEncoder.Value); err != nil { 4133 return out, metadata, &smithy.SerializationError{Err: err} 4134 } 4135 4136 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4137 return out, metadata, &smithy.SerializationError{Err: err} 4138 } 4139 4140 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4141 return out, metadata, &smithy.SerializationError{Err: err} 4142 } 4143 in.Request = request 4144 4145 return next.HandleSerialize(ctx, in) 4146} 4147func awsRestjson1_serializeOpHttpBindingsStartSimulationJobBatchInput(v *StartSimulationJobBatchInput, encoder *httpbinding.Encoder) error { 4148 if v == nil { 4149 return fmt.Errorf("unsupported serialization of nil %T", v) 4150 } 4151 4152 return nil 4153} 4154 4155func awsRestjson1_serializeOpDocumentStartSimulationJobBatchInput(v *StartSimulationJobBatchInput, value smithyjson.Value) error { 4156 object := value.Object() 4157 defer object.Close() 4158 4159 if v.BatchPolicy != nil { 4160 ok := object.Key("batchPolicy") 4161 if err := awsRestjson1_serializeDocumentBatchPolicy(v.BatchPolicy, ok); err != nil { 4162 return err 4163 } 4164 } 4165 4166 if v.ClientRequestToken != nil { 4167 ok := object.Key("clientRequestToken") 4168 ok.String(*v.ClientRequestToken) 4169 } 4170 4171 if v.CreateSimulationJobRequests != nil { 4172 ok := object.Key("createSimulationJobRequests") 4173 if err := awsRestjson1_serializeDocumentCreateSimulationJobRequests(v.CreateSimulationJobRequests, ok); err != nil { 4174 return err 4175 } 4176 } 4177 4178 if v.Tags != nil { 4179 ok := object.Key("tags") 4180 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 4181 return err 4182 } 4183 } 4184 4185 return nil 4186} 4187 4188type awsRestjson1_serializeOpSyncDeploymentJob struct { 4189} 4190 4191func (*awsRestjson1_serializeOpSyncDeploymentJob) ID() string { 4192 return "OperationSerializer" 4193} 4194 4195func (m *awsRestjson1_serializeOpSyncDeploymentJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4196 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4197) { 4198 request, ok := in.Request.(*smithyhttp.Request) 4199 if !ok { 4200 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4201 } 4202 4203 input, ok := in.Parameters.(*SyncDeploymentJobInput) 4204 _ = input 4205 if !ok { 4206 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4207 } 4208 4209 opPath, opQuery := httpbinding.SplitURI("/syncDeploymentJob") 4210 request.URL.Path = opPath 4211 if len(request.URL.RawQuery) > 0 { 4212 request.URL.RawQuery = "&" + opQuery 4213 } else { 4214 request.URL.RawQuery = opQuery 4215 } 4216 4217 request.Method = "POST" 4218 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4219 if err != nil { 4220 return out, metadata, &smithy.SerializationError{Err: err} 4221 } 4222 4223 restEncoder.SetHeader("Content-Type").String("application/json") 4224 4225 jsonEncoder := smithyjson.NewEncoder() 4226 if err := awsRestjson1_serializeOpDocumentSyncDeploymentJobInput(input, jsonEncoder.Value); err != nil { 4227 return out, metadata, &smithy.SerializationError{Err: err} 4228 } 4229 4230 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4231 return out, metadata, &smithy.SerializationError{Err: err} 4232 } 4233 4234 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4235 return out, metadata, &smithy.SerializationError{Err: err} 4236 } 4237 in.Request = request 4238 4239 return next.HandleSerialize(ctx, in) 4240} 4241func awsRestjson1_serializeOpHttpBindingsSyncDeploymentJobInput(v *SyncDeploymentJobInput, encoder *httpbinding.Encoder) error { 4242 if v == nil { 4243 return fmt.Errorf("unsupported serialization of nil %T", v) 4244 } 4245 4246 return nil 4247} 4248 4249func awsRestjson1_serializeOpDocumentSyncDeploymentJobInput(v *SyncDeploymentJobInput, value smithyjson.Value) error { 4250 object := value.Object() 4251 defer object.Close() 4252 4253 if v.ClientRequestToken != nil { 4254 ok := object.Key("clientRequestToken") 4255 ok.String(*v.ClientRequestToken) 4256 } 4257 4258 if v.Fleet != nil { 4259 ok := object.Key("fleet") 4260 ok.String(*v.Fleet) 4261 } 4262 4263 return nil 4264} 4265 4266type awsRestjson1_serializeOpTagResource struct { 4267} 4268 4269func (*awsRestjson1_serializeOpTagResource) ID() string { 4270 return "OperationSerializer" 4271} 4272 4273func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4274 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4275) { 4276 request, ok := in.Request.(*smithyhttp.Request) 4277 if !ok { 4278 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4279 } 4280 4281 input, ok := in.Parameters.(*TagResourceInput) 4282 _ = input 4283 if !ok { 4284 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4285 } 4286 4287 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 4288 request.URL.Path = opPath 4289 if len(request.URL.RawQuery) > 0 { 4290 request.URL.RawQuery = "&" + opQuery 4291 } else { 4292 request.URL.RawQuery = opQuery 4293 } 4294 4295 request.Method = "POST" 4296 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4297 if err != nil { 4298 return out, metadata, &smithy.SerializationError{Err: err} 4299 } 4300 4301 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 4302 return out, metadata, &smithy.SerializationError{Err: err} 4303 } 4304 4305 restEncoder.SetHeader("Content-Type").String("application/json") 4306 4307 jsonEncoder := smithyjson.NewEncoder() 4308 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 4309 return out, metadata, &smithy.SerializationError{Err: err} 4310 } 4311 4312 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4313 return out, metadata, &smithy.SerializationError{Err: err} 4314 } 4315 4316 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4317 return out, metadata, &smithy.SerializationError{Err: err} 4318 } 4319 in.Request = request 4320 4321 return next.HandleSerialize(ctx, in) 4322} 4323func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 4324 if v == nil { 4325 return fmt.Errorf("unsupported serialization of nil %T", v) 4326 } 4327 4328 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 4329 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 4330 } 4331 if v.ResourceArn != nil { 4332 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 4333 return err 4334 } 4335 } 4336 4337 return nil 4338} 4339 4340func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 4341 object := value.Object() 4342 defer object.Close() 4343 4344 if v.Tags != nil { 4345 ok := object.Key("tags") 4346 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 4347 return err 4348 } 4349 } 4350 4351 return nil 4352} 4353 4354type awsRestjson1_serializeOpUntagResource struct { 4355} 4356 4357func (*awsRestjson1_serializeOpUntagResource) ID() string { 4358 return "OperationSerializer" 4359} 4360 4361func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4362 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4363) { 4364 request, ok := in.Request.(*smithyhttp.Request) 4365 if !ok { 4366 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4367 } 4368 4369 input, ok := in.Parameters.(*UntagResourceInput) 4370 _ = input 4371 if !ok { 4372 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4373 } 4374 4375 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 4376 request.URL.Path = opPath 4377 if len(request.URL.RawQuery) > 0 { 4378 request.URL.RawQuery = "&" + opQuery 4379 } else { 4380 request.URL.RawQuery = opQuery 4381 } 4382 4383 request.Method = "DELETE" 4384 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4385 if err != nil { 4386 return out, metadata, &smithy.SerializationError{Err: err} 4387 } 4388 4389 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 4390 return out, metadata, &smithy.SerializationError{Err: err} 4391 } 4392 4393 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4394 return out, metadata, &smithy.SerializationError{Err: err} 4395 } 4396 in.Request = request 4397 4398 return next.HandleSerialize(ctx, in) 4399} 4400func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 4401 if v == nil { 4402 return fmt.Errorf("unsupported serialization of nil %T", v) 4403 } 4404 4405 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 4406 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 4407 } 4408 if v.ResourceArn != nil { 4409 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 4410 return err 4411 } 4412 } 4413 4414 if v.TagKeys != nil { 4415 for i := range v.TagKeys { 4416 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 4417 } 4418 } 4419 4420 return nil 4421} 4422 4423type awsRestjson1_serializeOpUpdateRobotApplication struct { 4424} 4425 4426func (*awsRestjson1_serializeOpUpdateRobotApplication) ID() string { 4427 return "OperationSerializer" 4428} 4429 4430func (m *awsRestjson1_serializeOpUpdateRobotApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4431 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4432) { 4433 request, ok := in.Request.(*smithyhttp.Request) 4434 if !ok { 4435 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4436 } 4437 4438 input, ok := in.Parameters.(*UpdateRobotApplicationInput) 4439 _ = input 4440 if !ok { 4441 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4442 } 4443 4444 opPath, opQuery := httpbinding.SplitURI("/updateRobotApplication") 4445 request.URL.Path = opPath 4446 if len(request.URL.RawQuery) > 0 { 4447 request.URL.RawQuery = "&" + opQuery 4448 } else { 4449 request.URL.RawQuery = opQuery 4450 } 4451 4452 request.Method = "POST" 4453 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4454 if err != nil { 4455 return out, metadata, &smithy.SerializationError{Err: err} 4456 } 4457 4458 restEncoder.SetHeader("Content-Type").String("application/json") 4459 4460 jsonEncoder := smithyjson.NewEncoder() 4461 if err := awsRestjson1_serializeOpDocumentUpdateRobotApplicationInput(input, jsonEncoder.Value); err != nil { 4462 return out, metadata, &smithy.SerializationError{Err: err} 4463 } 4464 4465 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4466 return out, metadata, &smithy.SerializationError{Err: err} 4467 } 4468 4469 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4470 return out, metadata, &smithy.SerializationError{Err: err} 4471 } 4472 in.Request = request 4473 4474 return next.HandleSerialize(ctx, in) 4475} 4476func awsRestjson1_serializeOpHttpBindingsUpdateRobotApplicationInput(v *UpdateRobotApplicationInput, encoder *httpbinding.Encoder) error { 4477 if v == nil { 4478 return fmt.Errorf("unsupported serialization of nil %T", v) 4479 } 4480 4481 return nil 4482} 4483 4484func awsRestjson1_serializeOpDocumentUpdateRobotApplicationInput(v *UpdateRobotApplicationInput, value smithyjson.Value) error { 4485 object := value.Object() 4486 defer object.Close() 4487 4488 if v.Application != nil { 4489 ok := object.Key("application") 4490 ok.String(*v.Application) 4491 } 4492 4493 if v.CurrentRevisionId != nil { 4494 ok := object.Key("currentRevisionId") 4495 ok.String(*v.CurrentRevisionId) 4496 } 4497 4498 if v.RobotSoftwareSuite != nil { 4499 ok := object.Key("robotSoftwareSuite") 4500 if err := awsRestjson1_serializeDocumentRobotSoftwareSuite(v.RobotSoftwareSuite, ok); err != nil { 4501 return err 4502 } 4503 } 4504 4505 if v.Sources != nil { 4506 ok := object.Key("sources") 4507 if err := awsRestjson1_serializeDocumentSourceConfigs(v.Sources, ok); err != nil { 4508 return err 4509 } 4510 } 4511 4512 return nil 4513} 4514 4515type awsRestjson1_serializeOpUpdateSimulationApplication struct { 4516} 4517 4518func (*awsRestjson1_serializeOpUpdateSimulationApplication) ID() string { 4519 return "OperationSerializer" 4520} 4521 4522func (m *awsRestjson1_serializeOpUpdateSimulationApplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4523 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4524) { 4525 request, ok := in.Request.(*smithyhttp.Request) 4526 if !ok { 4527 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4528 } 4529 4530 input, ok := in.Parameters.(*UpdateSimulationApplicationInput) 4531 _ = input 4532 if !ok { 4533 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4534 } 4535 4536 opPath, opQuery := httpbinding.SplitURI("/updateSimulationApplication") 4537 request.URL.Path = opPath 4538 if len(request.URL.RawQuery) > 0 { 4539 request.URL.RawQuery = "&" + opQuery 4540 } else { 4541 request.URL.RawQuery = opQuery 4542 } 4543 4544 request.Method = "POST" 4545 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4546 if err != nil { 4547 return out, metadata, &smithy.SerializationError{Err: err} 4548 } 4549 4550 restEncoder.SetHeader("Content-Type").String("application/json") 4551 4552 jsonEncoder := smithyjson.NewEncoder() 4553 if err := awsRestjson1_serializeOpDocumentUpdateSimulationApplicationInput(input, jsonEncoder.Value); err != nil { 4554 return out, metadata, &smithy.SerializationError{Err: err} 4555 } 4556 4557 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4558 return out, metadata, &smithy.SerializationError{Err: err} 4559 } 4560 4561 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4562 return out, metadata, &smithy.SerializationError{Err: err} 4563 } 4564 in.Request = request 4565 4566 return next.HandleSerialize(ctx, in) 4567} 4568func awsRestjson1_serializeOpHttpBindingsUpdateSimulationApplicationInput(v *UpdateSimulationApplicationInput, encoder *httpbinding.Encoder) error { 4569 if v == nil { 4570 return fmt.Errorf("unsupported serialization of nil %T", v) 4571 } 4572 4573 return nil 4574} 4575 4576func awsRestjson1_serializeOpDocumentUpdateSimulationApplicationInput(v *UpdateSimulationApplicationInput, value smithyjson.Value) error { 4577 object := value.Object() 4578 defer object.Close() 4579 4580 if v.Application != nil { 4581 ok := object.Key("application") 4582 ok.String(*v.Application) 4583 } 4584 4585 if v.CurrentRevisionId != nil { 4586 ok := object.Key("currentRevisionId") 4587 ok.String(*v.CurrentRevisionId) 4588 } 4589 4590 if v.RenderingEngine != nil { 4591 ok := object.Key("renderingEngine") 4592 if err := awsRestjson1_serializeDocumentRenderingEngine(v.RenderingEngine, ok); err != nil { 4593 return err 4594 } 4595 } 4596 4597 if v.RobotSoftwareSuite != nil { 4598 ok := object.Key("robotSoftwareSuite") 4599 if err := awsRestjson1_serializeDocumentRobotSoftwareSuite(v.RobotSoftwareSuite, ok); err != nil { 4600 return err 4601 } 4602 } 4603 4604 if v.SimulationSoftwareSuite != nil { 4605 ok := object.Key("simulationSoftwareSuite") 4606 if err := awsRestjson1_serializeDocumentSimulationSoftwareSuite(v.SimulationSoftwareSuite, ok); err != nil { 4607 return err 4608 } 4609 } 4610 4611 if v.Sources != nil { 4612 ok := object.Key("sources") 4613 if err := awsRestjson1_serializeDocumentSourceConfigs(v.Sources, ok); err != nil { 4614 return err 4615 } 4616 } 4617 4618 return nil 4619} 4620 4621type awsRestjson1_serializeOpUpdateWorldTemplate struct { 4622} 4623 4624func (*awsRestjson1_serializeOpUpdateWorldTemplate) ID() string { 4625 return "OperationSerializer" 4626} 4627 4628func (m *awsRestjson1_serializeOpUpdateWorldTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4629 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4630) { 4631 request, ok := in.Request.(*smithyhttp.Request) 4632 if !ok { 4633 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4634 } 4635 4636 input, ok := in.Parameters.(*UpdateWorldTemplateInput) 4637 _ = input 4638 if !ok { 4639 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4640 } 4641 4642 opPath, opQuery := httpbinding.SplitURI("/updateWorldTemplate") 4643 request.URL.Path = opPath 4644 if len(request.URL.RawQuery) > 0 { 4645 request.URL.RawQuery = "&" + opQuery 4646 } else { 4647 request.URL.RawQuery = opQuery 4648 } 4649 4650 request.Method = "POST" 4651 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4652 if err != nil { 4653 return out, metadata, &smithy.SerializationError{Err: err} 4654 } 4655 4656 restEncoder.SetHeader("Content-Type").String("application/json") 4657 4658 jsonEncoder := smithyjson.NewEncoder() 4659 if err := awsRestjson1_serializeOpDocumentUpdateWorldTemplateInput(input, jsonEncoder.Value); err != nil { 4660 return out, metadata, &smithy.SerializationError{Err: err} 4661 } 4662 4663 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4664 return out, metadata, &smithy.SerializationError{Err: err} 4665 } 4666 4667 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4668 return out, metadata, &smithy.SerializationError{Err: err} 4669 } 4670 in.Request = request 4671 4672 return next.HandleSerialize(ctx, in) 4673} 4674func awsRestjson1_serializeOpHttpBindingsUpdateWorldTemplateInput(v *UpdateWorldTemplateInput, encoder *httpbinding.Encoder) error { 4675 if v == nil { 4676 return fmt.Errorf("unsupported serialization of nil %T", v) 4677 } 4678 4679 return nil 4680} 4681 4682func awsRestjson1_serializeOpDocumentUpdateWorldTemplateInput(v *UpdateWorldTemplateInput, value smithyjson.Value) error { 4683 object := value.Object() 4684 defer object.Close() 4685 4686 if v.Name != nil { 4687 ok := object.Key("name") 4688 ok.String(*v.Name) 4689 } 4690 4691 if v.Template != nil { 4692 ok := object.Key("template") 4693 ok.String(*v.Template) 4694 } 4695 4696 if v.TemplateBody != nil { 4697 ok := object.Key("templateBody") 4698 ok.String(*v.TemplateBody) 4699 } 4700 4701 if v.TemplateLocation != nil { 4702 ok := object.Key("templateLocation") 4703 if err := awsRestjson1_serializeDocumentTemplateLocation(v.TemplateLocation, ok); err != nil { 4704 return err 4705 } 4706 } 4707 4708 return nil 4709} 4710 4711func awsRestjson1_serializeDocumentArns(v []string, value smithyjson.Value) error { 4712 array := value.Array() 4713 defer array.Close() 4714 4715 for i := range v { 4716 av := array.Value() 4717 av.String(v[i]) 4718 } 4719 return nil 4720} 4721 4722func awsRestjson1_serializeDocumentBatchPolicy(v *types.BatchPolicy, value smithyjson.Value) error { 4723 object := value.Object() 4724 defer object.Close() 4725 4726 if v.MaxConcurrency != nil { 4727 ok := object.Key("maxConcurrency") 4728 ok.Integer(*v.MaxConcurrency) 4729 } 4730 4731 if v.TimeoutInSeconds != nil { 4732 ok := object.Key("timeoutInSeconds") 4733 ok.Long(*v.TimeoutInSeconds) 4734 } 4735 4736 return nil 4737} 4738 4739func awsRestjson1_serializeDocumentCompute(v *types.Compute, value smithyjson.Value) error { 4740 object := value.Object() 4741 defer object.Close() 4742 4743 if v.SimulationUnitLimit != nil { 4744 ok := object.Key("simulationUnitLimit") 4745 ok.Integer(*v.SimulationUnitLimit) 4746 } 4747 4748 return nil 4749} 4750 4751func awsRestjson1_serializeDocumentCreateSimulationJobRequests(v []types.SimulationJobRequest, value smithyjson.Value) error { 4752 array := value.Array() 4753 defer array.Close() 4754 4755 for i := range v { 4756 av := array.Value() 4757 if err := awsRestjson1_serializeDocumentSimulationJobRequest(&v[i], av); err != nil { 4758 return err 4759 } 4760 } 4761 return nil 4762} 4763 4764func awsRestjson1_serializeDocumentDataSourceConfig(v *types.DataSourceConfig, value smithyjson.Value) error { 4765 object := value.Object() 4766 defer object.Close() 4767 4768 if v.Name != nil { 4769 ok := object.Key("name") 4770 ok.String(*v.Name) 4771 } 4772 4773 if v.S3Bucket != nil { 4774 ok := object.Key("s3Bucket") 4775 ok.String(*v.S3Bucket) 4776 } 4777 4778 if v.S3Keys != nil { 4779 ok := object.Key("s3Keys") 4780 if err := awsRestjson1_serializeDocumentS3Keys(v.S3Keys, ok); err != nil { 4781 return err 4782 } 4783 } 4784 4785 return nil 4786} 4787 4788func awsRestjson1_serializeDocumentDataSourceConfigs(v []types.DataSourceConfig, value smithyjson.Value) error { 4789 array := value.Array() 4790 defer array.Close() 4791 4792 for i := range v { 4793 av := array.Value() 4794 if err := awsRestjson1_serializeDocumentDataSourceConfig(&v[i], av); err != nil { 4795 return err 4796 } 4797 } 4798 return nil 4799} 4800 4801func awsRestjson1_serializeDocumentDeploymentApplicationConfig(v *types.DeploymentApplicationConfig, value smithyjson.Value) error { 4802 object := value.Object() 4803 defer object.Close() 4804 4805 if v.Application != nil { 4806 ok := object.Key("application") 4807 ok.String(*v.Application) 4808 } 4809 4810 if v.ApplicationVersion != nil { 4811 ok := object.Key("applicationVersion") 4812 ok.String(*v.ApplicationVersion) 4813 } 4814 4815 if v.LaunchConfig != nil { 4816 ok := object.Key("launchConfig") 4817 if err := awsRestjson1_serializeDocumentDeploymentLaunchConfig(v.LaunchConfig, ok); err != nil { 4818 return err 4819 } 4820 } 4821 4822 return nil 4823} 4824 4825func awsRestjson1_serializeDocumentDeploymentApplicationConfigs(v []types.DeploymentApplicationConfig, value smithyjson.Value) error { 4826 array := value.Array() 4827 defer array.Close() 4828 4829 for i := range v { 4830 av := array.Value() 4831 if err := awsRestjson1_serializeDocumentDeploymentApplicationConfig(&v[i], av); err != nil { 4832 return err 4833 } 4834 } 4835 return nil 4836} 4837 4838func awsRestjson1_serializeDocumentDeploymentConfig(v *types.DeploymentConfig, value smithyjson.Value) error { 4839 object := value.Object() 4840 defer object.Close() 4841 4842 if v.ConcurrentDeploymentPercentage != nil { 4843 ok := object.Key("concurrentDeploymentPercentage") 4844 ok.Integer(*v.ConcurrentDeploymentPercentage) 4845 } 4846 4847 if v.DownloadConditionFile != nil { 4848 ok := object.Key("downloadConditionFile") 4849 if err := awsRestjson1_serializeDocumentS3Object(v.DownloadConditionFile, ok); err != nil { 4850 return err 4851 } 4852 } 4853 4854 if v.FailureThresholdPercentage != nil { 4855 ok := object.Key("failureThresholdPercentage") 4856 ok.Integer(*v.FailureThresholdPercentage) 4857 } 4858 4859 if v.RobotDeploymentTimeoutInSeconds != nil { 4860 ok := object.Key("robotDeploymentTimeoutInSeconds") 4861 ok.Long(*v.RobotDeploymentTimeoutInSeconds) 4862 } 4863 4864 return nil 4865} 4866 4867func awsRestjson1_serializeDocumentDeploymentLaunchConfig(v *types.DeploymentLaunchConfig, value smithyjson.Value) error { 4868 object := value.Object() 4869 defer object.Close() 4870 4871 if v.EnvironmentVariables != nil { 4872 ok := object.Key("environmentVariables") 4873 if err := awsRestjson1_serializeDocumentEnvironmentVariableMap(v.EnvironmentVariables, ok); err != nil { 4874 return err 4875 } 4876 } 4877 4878 if v.LaunchFile != nil { 4879 ok := object.Key("launchFile") 4880 ok.String(*v.LaunchFile) 4881 } 4882 4883 if v.PackageName != nil { 4884 ok := object.Key("packageName") 4885 ok.String(*v.PackageName) 4886 } 4887 4888 if v.PostLaunchFile != nil { 4889 ok := object.Key("postLaunchFile") 4890 ok.String(*v.PostLaunchFile) 4891 } 4892 4893 if v.PreLaunchFile != nil { 4894 ok := object.Key("preLaunchFile") 4895 ok.String(*v.PreLaunchFile) 4896 } 4897 4898 return nil 4899} 4900 4901func awsRestjson1_serializeDocumentEnvironmentVariableMap(v map[string]string, value smithyjson.Value) error { 4902 object := value.Object() 4903 defer object.Close() 4904 4905 for key := range v { 4906 om := object.Key(key) 4907 om.String(v[key]) 4908 } 4909 return nil 4910} 4911 4912func awsRestjson1_serializeDocumentFilter(v *types.Filter, value smithyjson.Value) error { 4913 object := value.Object() 4914 defer object.Close() 4915 4916 if v.Name != nil { 4917 ok := object.Key("name") 4918 ok.String(*v.Name) 4919 } 4920 4921 if v.Values != nil { 4922 ok := object.Key("values") 4923 if err := awsRestjson1_serializeDocumentFilterValues(v.Values, ok); err != nil { 4924 return err 4925 } 4926 } 4927 4928 return nil 4929} 4930 4931func awsRestjson1_serializeDocumentFilters(v []types.Filter, value smithyjson.Value) error { 4932 array := value.Array() 4933 defer array.Close() 4934 4935 for i := range v { 4936 av := array.Value() 4937 if err := awsRestjson1_serializeDocumentFilter(&v[i], av); err != nil { 4938 return err 4939 } 4940 } 4941 return nil 4942} 4943 4944func awsRestjson1_serializeDocumentFilterValues(v []string, value smithyjson.Value) error { 4945 array := value.Array() 4946 defer array.Close() 4947 4948 for i := range v { 4949 av := array.Value() 4950 av.String(v[i]) 4951 } 4952 return nil 4953} 4954 4955func awsRestjson1_serializeDocumentLaunchConfig(v *types.LaunchConfig, value smithyjson.Value) error { 4956 object := value.Object() 4957 defer object.Close() 4958 4959 if v.EnvironmentVariables != nil { 4960 ok := object.Key("environmentVariables") 4961 if err := awsRestjson1_serializeDocumentEnvironmentVariableMap(v.EnvironmentVariables, ok); err != nil { 4962 return err 4963 } 4964 } 4965 4966 if v.LaunchFile != nil { 4967 ok := object.Key("launchFile") 4968 ok.String(*v.LaunchFile) 4969 } 4970 4971 if v.PackageName != nil { 4972 ok := object.Key("packageName") 4973 ok.String(*v.PackageName) 4974 } 4975 4976 if v.PortForwardingConfig != nil { 4977 ok := object.Key("portForwardingConfig") 4978 if err := awsRestjson1_serializeDocumentPortForwardingConfig(v.PortForwardingConfig, ok); err != nil { 4979 return err 4980 } 4981 } 4982 4983 if v.StreamUI { 4984 ok := object.Key("streamUI") 4985 ok.Boolean(v.StreamUI) 4986 } 4987 4988 return nil 4989} 4990 4991func awsRestjson1_serializeDocumentLoggingConfig(v *types.LoggingConfig, value smithyjson.Value) error { 4992 object := value.Object() 4993 defer object.Close() 4994 4995 if v.RecordAllRosTopics != nil { 4996 ok := object.Key("recordAllRosTopics") 4997 ok.Boolean(*v.RecordAllRosTopics) 4998 } 4999 5000 return nil 5001} 5002 5003func awsRestjson1_serializeDocumentOutputLocation(v *types.OutputLocation, value smithyjson.Value) error { 5004 object := value.Object() 5005 defer object.Close() 5006 5007 if v.S3Bucket != nil { 5008 ok := object.Key("s3Bucket") 5009 ok.String(*v.S3Bucket) 5010 } 5011 5012 if v.S3Prefix != nil { 5013 ok := object.Key("s3Prefix") 5014 ok.String(*v.S3Prefix) 5015 } 5016 5017 return nil 5018} 5019 5020func awsRestjson1_serializeDocumentPortForwardingConfig(v *types.PortForwardingConfig, value smithyjson.Value) error { 5021 object := value.Object() 5022 defer object.Close() 5023 5024 if v.PortMappings != nil { 5025 ok := object.Key("portMappings") 5026 if err := awsRestjson1_serializeDocumentPortMappingList(v.PortMappings, ok); err != nil { 5027 return err 5028 } 5029 } 5030 5031 return nil 5032} 5033 5034func awsRestjson1_serializeDocumentPortMapping(v *types.PortMapping, value smithyjson.Value) error { 5035 object := value.Object() 5036 defer object.Close() 5037 5038 if v.ApplicationPort != 0 { 5039 ok := object.Key("applicationPort") 5040 ok.Integer(v.ApplicationPort) 5041 } 5042 5043 if v.EnableOnPublicIp { 5044 ok := object.Key("enableOnPublicIp") 5045 ok.Boolean(v.EnableOnPublicIp) 5046 } 5047 5048 if v.JobPort != 0 { 5049 ok := object.Key("jobPort") 5050 ok.Integer(v.JobPort) 5051 } 5052 5053 return nil 5054} 5055 5056func awsRestjson1_serializeDocumentPortMappingList(v []types.PortMapping, value smithyjson.Value) error { 5057 array := value.Array() 5058 defer array.Close() 5059 5060 for i := range v { 5061 av := array.Value() 5062 if err := awsRestjson1_serializeDocumentPortMapping(&v[i], av); err != nil { 5063 return err 5064 } 5065 } 5066 return nil 5067} 5068 5069func awsRestjson1_serializeDocumentRenderingEngine(v *types.RenderingEngine, value smithyjson.Value) error { 5070 object := value.Object() 5071 defer object.Close() 5072 5073 if len(v.Name) > 0 { 5074 ok := object.Key("name") 5075 ok.String(string(v.Name)) 5076 } 5077 5078 if v.Version != nil { 5079 ok := object.Key("version") 5080 ok.String(*v.Version) 5081 } 5082 5083 return nil 5084} 5085 5086func awsRestjson1_serializeDocumentRobotApplicationConfig(v *types.RobotApplicationConfig, value smithyjson.Value) error { 5087 object := value.Object() 5088 defer object.Close() 5089 5090 if v.Application != nil { 5091 ok := object.Key("application") 5092 ok.String(*v.Application) 5093 } 5094 5095 if v.ApplicationVersion != nil { 5096 ok := object.Key("applicationVersion") 5097 ok.String(*v.ApplicationVersion) 5098 } 5099 5100 if v.LaunchConfig != nil { 5101 ok := object.Key("launchConfig") 5102 if err := awsRestjson1_serializeDocumentLaunchConfig(v.LaunchConfig, ok); err != nil { 5103 return err 5104 } 5105 } 5106 5107 return nil 5108} 5109 5110func awsRestjson1_serializeDocumentRobotApplicationConfigs(v []types.RobotApplicationConfig, value smithyjson.Value) error { 5111 array := value.Array() 5112 defer array.Close() 5113 5114 for i := range v { 5115 av := array.Value() 5116 if err := awsRestjson1_serializeDocumentRobotApplicationConfig(&v[i], av); err != nil { 5117 return err 5118 } 5119 } 5120 return nil 5121} 5122 5123func awsRestjson1_serializeDocumentRobotSoftwareSuite(v *types.RobotSoftwareSuite, value smithyjson.Value) error { 5124 object := value.Object() 5125 defer object.Close() 5126 5127 if len(v.Name) > 0 { 5128 ok := object.Key("name") 5129 ok.String(string(v.Name)) 5130 } 5131 5132 if len(v.Version) > 0 { 5133 ok := object.Key("version") 5134 ok.String(string(v.Version)) 5135 } 5136 5137 return nil 5138} 5139 5140func awsRestjson1_serializeDocumentS3Keys(v []string, value smithyjson.Value) error { 5141 array := value.Array() 5142 defer array.Close() 5143 5144 for i := range v { 5145 av := array.Value() 5146 av.String(v[i]) 5147 } 5148 return nil 5149} 5150 5151func awsRestjson1_serializeDocumentS3Object(v *types.S3Object, value smithyjson.Value) error { 5152 object := value.Object() 5153 defer object.Close() 5154 5155 if v.Bucket != nil { 5156 ok := object.Key("bucket") 5157 ok.String(*v.Bucket) 5158 } 5159 5160 if v.Etag != nil { 5161 ok := object.Key("etag") 5162 ok.String(*v.Etag) 5163 } 5164 5165 if v.Key != nil { 5166 ok := object.Key("key") 5167 ok.String(*v.Key) 5168 } 5169 5170 return nil 5171} 5172 5173func awsRestjson1_serializeDocumentSecurityGroups(v []string, value smithyjson.Value) error { 5174 array := value.Array() 5175 defer array.Close() 5176 5177 for i := range v { 5178 av := array.Value() 5179 av.String(v[i]) 5180 } 5181 return nil 5182} 5183 5184func awsRestjson1_serializeDocumentSimulationApplicationConfig(v *types.SimulationApplicationConfig, value smithyjson.Value) error { 5185 object := value.Object() 5186 defer object.Close() 5187 5188 if v.Application != nil { 5189 ok := object.Key("application") 5190 ok.String(*v.Application) 5191 } 5192 5193 if v.ApplicationVersion != nil { 5194 ok := object.Key("applicationVersion") 5195 ok.String(*v.ApplicationVersion) 5196 } 5197 5198 if v.LaunchConfig != nil { 5199 ok := object.Key("launchConfig") 5200 if err := awsRestjson1_serializeDocumentLaunchConfig(v.LaunchConfig, ok); err != nil { 5201 return err 5202 } 5203 } 5204 5205 if v.WorldConfigs != nil { 5206 ok := object.Key("worldConfigs") 5207 if err := awsRestjson1_serializeDocumentWorldConfigs(v.WorldConfigs, ok); err != nil { 5208 return err 5209 } 5210 } 5211 5212 return nil 5213} 5214 5215func awsRestjson1_serializeDocumentSimulationApplicationConfigs(v []types.SimulationApplicationConfig, value smithyjson.Value) error { 5216 array := value.Array() 5217 defer array.Close() 5218 5219 for i := range v { 5220 av := array.Value() 5221 if err := awsRestjson1_serializeDocumentSimulationApplicationConfig(&v[i], av); err != nil { 5222 return err 5223 } 5224 } 5225 return nil 5226} 5227 5228func awsRestjson1_serializeDocumentSimulationJobRequest(v *types.SimulationJobRequest, value smithyjson.Value) error { 5229 object := value.Object() 5230 defer object.Close() 5231 5232 if v.Compute != nil { 5233 ok := object.Key("compute") 5234 if err := awsRestjson1_serializeDocumentCompute(v.Compute, ok); err != nil { 5235 return err 5236 } 5237 } 5238 5239 if v.DataSources != nil { 5240 ok := object.Key("dataSources") 5241 if err := awsRestjson1_serializeDocumentDataSourceConfigs(v.DataSources, ok); err != nil { 5242 return err 5243 } 5244 } 5245 5246 if len(v.FailureBehavior) > 0 { 5247 ok := object.Key("failureBehavior") 5248 ok.String(string(v.FailureBehavior)) 5249 } 5250 5251 if v.IamRole != nil { 5252 ok := object.Key("iamRole") 5253 ok.String(*v.IamRole) 5254 } 5255 5256 if v.LoggingConfig != nil { 5257 ok := object.Key("loggingConfig") 5258 if err := awsRestjson1_serializeDocumentLoggingConfig(v.LoggingConfig, ok); err != nil { 5259 return err 5260 } 5261 } 5262 5263 if v.MaxJobDurationInSeconds != 0 { 5264 ok := object.Key("maxJobDurationInSeconds") 5265 ok.Long(v.MaxJobDurationInSeconds) 5266 } 5267 5268 if v.OutputLocation != nil { 5269 ok := object.Key("outputLocation") 5270 if err := awsRestjson1_serializeDocumentOutputLocation(v.OutputLocation, ok); err != nil { 5271 return err 5272 } 5273 } 5274 5275 if v.RobotApplications != nil { 5276 ok := object.Key("robotApplications") 5277 if err := awsRestjson1_serializeDocumentRobotApplicationConfigs(v.RobotApplications, ok); err != nil { 5278 return err 5279 } 5280 } 5281 5282 if v.SimulationApplications != nil { 5283 ok := object.Key("simulationApplications") 5284 if err := awsRestjson1_serializeDocumentSimulationApplicationConfigs(v.SimulationApplications, ok); err != nil { 5285 return err 5286 } 5287 } 5288 5289 if v.Tags != nil { 5290 ok := object.Key("tags") 5291 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 5292 return err 5293 } 5294 } 5295 5296 if v.UseDefaultApplications != nil { 5297 ok := object.Key("useDefaultApplications") 5298 ok.Boolean(*v.UseDefaultApplications) 5299 } 5300 5301 if v.VpcConfig != nil { 5302 ok := object.Key("vpcConfig") 5303 if err := awsRestjson1_serializeDocumentVPCConfig(v.VpcConfig, ok); err != nil { 5304 return err 5305 } 5306 } 5307 5308 return nil 5309} 5310 5311func awsRestjson1_serializeDocumentSimulationSoftwareSuite(v *types.SimulationSoftwareSuite, value smithyjson.Value) error { 5312 object := value.Object() 5313 defer object.Close() 5314 5315 if len(v.Name) > 0 { 5316 ok := object.Key("name") 5317 ok.String(string(v.Name)) 5318 } 5319 5320 if v.Version != nil { 5321 ok := object.Key("version") 5322 ok.String(*v.Version) 5323 } 5324 5325 return nil 5326} 5327 5328func awsRestjson1_serializeDocumentSourceConfig(v *types.SourceConfig, value smithyjson.Value) error { 5329 object := value.Object() 5330 defer object.Close() 5331 5332 if len(v.Architecture) > 0 { 5333 ok := object.Key("architecture") 5334 ok.String(string(v.Architecture)) 5335 } 5336 5337 if v.S3Bucket != nil { 5338 ok := object.Key("s3Bucket") 5339 ok.String(*v.S3Bucket) 5340 } 5341 5342 if v.S3Key != nil { 5343 ok := object.Key("s3Key") 5344 ok.String(*v.S3Key) 5345 } 5346 5347 return nil 5348} 5349 5350func awsRestjson1_serializeDocumentSourceConfigs(v []types.SourceConfig, value smithyjson.Value) error { 5351 array := value.Array() 5352 defer array.Close() 5353 5354 for i := range v { 5355 av := array.Value() 5356 if err := awsRestjson1_serializeDocumentSourceConfig(&v[i], av); err != nil { 5357 return err 5358 } 5359 } 5360 return nil 5361} 5362 5363func awsRestjson1_serializeDocumentSubnets(v []string, value smithyjson.Value) error { 5364 array := value.Array() 5365 defer array.Close() 5366 5367 for i := range v { 5368 av := array.Value() 5369 av.String(v[i]) 5370 } 5371 return nil 5372} 5373 5374func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 5375 object := value.Object() 5376 defer object.Close() 5377 5378 for key := range v { 5379 om := object.Key(key) 5380 om.String(v[key]) 5381 } 5382 return nil 5383} 5384 5385func awsRestjson1_serializeDocumentTemplateLocation(v *types.TemplateLocation, value smithyjson.Value) error { 5386 object := value.Object() 5387 defer object.Close() 5388 5389 if v.S3Bucket != nil { 5390 ok := object.Key("s3Bucket") 5391 ok.String(*v.S3Bucket) 5392 } 5393 5394 if v.S3Key != nil { 5395 ok := object.Key("s3Key") 5396 ok.String(*v.S3Key) 5397 } 5398 5399 return nil 5400} 5401 5402func awsRestjson1_serializeDocumentVPCConfig(v *types.VPCConfig, value smithyjson.Value) error { 5403 object := value.Object() 5404 defer object.Close() 5405 5406 if v.AssignPublicIp { 5407 ok := object.Key("assignPublicIp") 5408 ok.Boolean(v.AssignPublicIp) 5409 } 5410 5411 if v.SecurityGroups != nil { 5412 ok := object.Key("securityGroups") 5413 if err := awsRestjson1_serializeDocumentSecurityGroups(v.SecurityGroups, ok); err != nil { 5414 return err 5415 } 5416 } 5417 5418 if v.Subnets != nil { 5419 ok := object.Key("subnets") 5420 if err := awsRestjson1_serializeDocumentSubnets(v.Subnets, ok); err != nil { 5421 return err 5422 } 5423 } 5424 5425 return nil 5426} 5427 5428func awsRestjson1_serializeDocumentWorldConfig(v *types.WorldConfig, value smithyjson.Value) error { 5429 object := value.Object() 5430 defer object.Close() 5431 5432 if v.World != nil { 5433 ok := object.Key("world") 5434 ok.String(*v.World) 5435 } 5436 5437 return nil 5438} 5439 5440func awsRestjson1_serializeDocumentWorldConfigs(v []types.WorldConfig, value smithyjson.Value) error { 5441 array := value.Array() 5442 defer array.Close() 5443 5444 for i := range v { 5445 av := array.Value() 5446 if err := awsRestjson1_serializeDocumentWorldConfig(&v[i], av); err != nil { 5447 return err 5448 } 5449 } 5450 return nil 5451} 5452 5453func awsRestjson1_serializeDocumentWorldCount(v *types.WorldCount, value smithyjson.Value) error { 5454 object := value.Object() 5455 defer object.Close() 5456 5457 if v.FloorplanCount != nil { 5458 ok := object.Key("floorplanCount") 5459 ok.Integer(*v.FloorplanCount) 5460 } 5461 5462 if v.InteriorCountPerFloorplan != nil { 5463 ok := object.Key("interiorCountPerFloorplan") 5464 ok.Integer(*v.InteriorCountPerFloorplan) 5465 } 5466 5467 return nil 5468} 5469