1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package greengrass 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/greengrass/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_serializeOpAssociateRoleToGroup struct { 18} 19 20func (*awsRestjson1_serializeOpAssociateRoleToGroup) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpAssociateRoleToGroup) 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.(*AssociateRoleToGroupInput) 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("/greengrass/groups/{GroupId}/role") 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 = "PUT" 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 if err := awsRestjson1_serializeOpHttpBindingsAssociateRoleToGroupInput(input, restEncoder); err != nil { 53 return out, metadata, &smithy.SerializationError{Err: err} 54 } 55 56 restEncoder.SetHeader("Content-Type").String("application/json") 57 58 jsonEncoder := smithyjson.NewEncoder() 59 if err := awsRestjson1_serializeOpDocumentAssociateRoleToGroupInput(input, jsonEncoder.Value); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 63 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 64 return out, metadata, &smithy.SerializationError{Err: err} 65 } 66 67 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 68 return out, metadata, &smithy.SerializationError{Err: err} 69 } 70 in.Request = request 71 72 return next.HandleSerialize(ctx, in) 73} 74func awsRestjson1_serializeOpHttpBindingsAssociateRoleToGroupInput(v *AssociateRoleToGroupInput, encoder *httpbinding.Encoder) error { 75 if v == nil { 76 return fmt.Errorf("unsupported serialization of nil %T", v) 77 } 78 79 if v.GroupId == nil || len(*v.GroupId) == 0 { 80 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 81 } 82 if v.GroupId != nil { 83 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 84 return err 85 } 86 } 87 88 return nil 89} 90 91func awsRestjson1_serializeOpDocumentAssociateRoleToGroupInput(v *AssociateRoleToGroupInput, value smithyjson.Value) error { 92 object := value.Object() 93 defer object.Close() 94 95 if v.RoleArn != nil { 96 ok := object.Key("RoleArn") 97 ok.String(*v.RoleArn) 98 } 99 100 return nil 101} 102 103type awsRestjson1_serializeOpAssociateServiceRoleToAccount struct { 104} 105 106func (*awsRestjson1_serializeOpAssociateServiceRoleToAccount) ID() string { 107 return "OperationSerializer" 108} 109 110func (m *awsRestjson1_serializeOpAssociateServiceRoleToAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 111 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 112) { 113 request, ok := in.Request.(*smithyhttp.Request) 114 if !ok { 115 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 116 } 117 118 input, ok := in.Parameters.(*AssociateServiceRoleToAccountInput) 119 _ = input 120 if !ok { 121 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 122 } 123 124 opPath, opQuery := httpbinding.SplitURI("/greengrass/servicerole") 125 request.URL.Path = opPath 126 if len(request.URL.RawQuery) > 0 { 127 request.URL.RawQuery = "&" + opQuery 128 } else { 129 request.URL.RawQuery = opQuery 130 } 131 132 request.Method = "PUT" 133 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 134 if err != nil { 135 return out, metadata, &smithy.SerializationError{Err: err} 136 } 137 138 restEncoder.SetHeader("Content-Type").String("application/json") 139 140 jsonEncoder := smithyjson.NewEncoder() 141 if err := awsRestjson1_serializeOpDocumentAssociateServiceRoleToAccountInput(input, jsonEncoder.Value); err != nil { 142 return out, metadata, &smithy.SerializationError{Err: err} 143 } 144 145 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 146 return out, metadata, &smithy.SerializationError{Err: err} 147 } 148 149 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 150 return out, metadata, &smithy.SerializationError{Err: err} 151 } 152 in.Request = request 153 154 return next.HandleSerialize(ctx, in) 155} 156func awsRestjson1_serializeOpHttpBindingsAssociateServiceRoleToAccountInput(v *AssociateServiceRoleToAccountInput, encoder *httpbinding.Encoder) error { 157 if v == nil { 158 return fmt.Errorf("unsupported serialization of nil %T", v) 159 } 160 161 return nil 162} 163 164func awsRestjson1_serializeOpDocumentAssociateServiceRoleToAccountInput(v *AssociateServiceRoleToAccountInput, value smithyjson.Value) error { 165 object := value.Object() 166 defer object.Close() 167 168 if v.RoleArn != nil { 169 ok := object.Key("RoleArn") 170 ok.String(*v.RoleArn) 171 } 172 173 return nil 174} 175 176type awsRestjson1_serializeOpCreateConnectorDefinition struct { 177} 178 179func (*awsRestjson1_serializeOpCreateConnectorDefinition) ID() string { 180 return "OperationSerializer" 181} 182 183func (m *awsRestjson1_serializeOpCreateConnectorDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 184 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 185) { 186 request, ok := in.Request.(*smithyhttp.Request) 187 if !ok { 188 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 189 } 190 191 input, ok := in.Parameters.(*CreateConnectorDefinitionInput) 192 _ = input 193 if !ok { 194 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 195 } 196 197 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors") 198 request.URL.Path = opPath 199 if len(request.URL.RawQuery) > 0 { 200 request.URL.RawQuery = "&" + opQuery 201 } else { 202 request.URL.RawQuery = opQuery 203 } 204 205 request.Method = "POST" 206 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 207 if err != nil { 208 return out, metadata, &smithy.SerializationError{Err: err} 209 } 210 211 if err := awsRestjson1_serializeOpHttpBindingsCreateConnectorDefinitionInput(input, restEncoder); err != nil { 212 return out, metadata, &smithy.SerializationError{Err: err} 213 } 214 215 restEncoder.SetHeader("Content-Type").String("application/json") 216 217 jsonEncoder := smithyjson.NewEncoder() 218 if err := awsRestjson1_serializeOpDocumentCreateConnectorDefinitionInput(input, jsonEncoder.Value); err != nil { 219 return out, metadata, &smithy.SerializationError{Err: err} 220 } 221 222 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 223 return out, metadata, &smithy.SerializationError{Err: err} 224 } 225 226 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 227 return out, metadata, &smithy.SerializationError{Err: err} 228 } 229 in.Request = request 230 231 return next.HandleSerialize(ctx, in) 232} 233func awsRestjson1_serializeOpHttpBindingsCreateConnectorDefinitionInput(v *CreateConnectorDefinitionInput, encoder *httpbinding.Encoder) error { 234 if v == nil { 235 return fmt.Errorf("unsupported serialization of nil %T", v) 236 } 237 238 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 239 locationName := "X-Amzn-Client-Token" 240 encoder.SetHeader(locationName).String(*v.AmznClientToken) 241 } 242 243 return nil 244} 245 246func awsRestjson1_serializeOpDocumentCreateConnectorDefinitionInput(v *CreateConnectorDefinitionInput, value smithyjson.Value) error { 247 object := value.Object() 248 defer object.Close() 249 250 if v.InitialVersion != nil { 251 ok := object.Key("InitialVersion") 252 if err := awsRestjson1_serializeDocumentConnectorDefinitionVersion(v.InitialVersion, ok); err != nil { 253 return err 254 } 255 } 256 257 if v.Name != nil { 258 ok := object.Key("Name") 259 ok.String(*v.Name) 260 } 261 262 if v.Tags != nil { 263 ok := object.Key("tags") 264 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 265 return err 266 } 267 } 268 269 return nil 270} 271 272type awsRestjson1_serializeOpCreateConnectorDefinitionVersion struct { 273} 274 275func (*awsRestjson1_serializeOpCreateConnectorDefinitionVersion) ID() string { 276 return "OperationSerializer" 277} 278 279func (m *awsRestjson1_serializeOpCreateConnectorDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 280 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 281) { 282 request, ok := in.Request.(*smithyhttp.Request) 283 if !ok { 284 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 285 } 286 287 input, ok := in.Parameters.(*CreateConnectorDefinitionVersionInput) 288 _ = input 289 if !ok { 290 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 291 } 292 293 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions") 294 request.URL.Path = opPath 295 if len(request.URL.RawQuery) > 0 { 296 request.URL.RawQuery = "&" + opQuery 297 } else { 298 request.URL.RawQuery = opQuery 299 } 300 301 request.Method = "POST" 302 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 303 if err != nil { 304 return out, metadata, &smithy.SerializationError{Err: err} 305 } 306 307 if err := awsRestjson1_serializeOpHttpBindingsCreateConnectorDefinitionVersionInput(input, restEncoder); err != nil { 308 return out, metadata, &smithy.SerializationError{Err: err} 309 } 310 311 restEncoder.SetHeader("Content-Type").String("application/json") 312 313 jsonEncoder := smithyjson.NewEncoder() 314 if err := awsRestjson1_serializeOpDocumentCreateConnectorDefinitionVersionInput(input, jsonEncoder.Value); err != nil { 315 return out, metadata, &smithy.SerializationError{Err: err} 316 } 317 318 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 319 return out, metadata, &smithy.SerializationError{Err: err} 320 } 321 322 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 323 return out, metadata, &smithy.SerializationError{Err: err} 324 } 325 in.Request = request 326 327 return next.HandleSerialize(ctx, in) 328} 329func awsRestjson1_serializeOpHttpBindingsCreateConnectorDefinitionVersionInput(v *CreateConnectorDefinitionVersionInput, encoder *httpbinding.Encoder) error { 330 if v == nil { 331 return fmt.Errorf("unsupported serialization of nil %T", v) 332 } 333 334 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 335 locationName := "X-Amzn-Client-Token" 336 encoder.SetHeader(locationName).String(*v.AmznClientToken) 337 } 338 339 if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 { 340 return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")} 341 } 342 if v.ConnectorDefinitionId != nil { 343 if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil { 344 return err 345 } 346 } 347 348 return nil 349} 350 351func awsRestjson1_serializeOpDocumentCreateConnectorDefinitionVersionInput(v *CreateConnectorDefinitionVersionInput, value smithyjson.Value) error { 352 object := value.Object() 353 defer object.Close() 354 355 if v.Connectors != nil { 356 ok := object.Key("Connectors") 357 if err := awsRestjson1_serializeDocument__listOfConnector(v.Connectors, ok); err != nil { 358 return err 359 } 360 } 361 362 return nil 363} 364 365type awsRestjson1_serializeOpCreateCoreDefinition struct { 366} 367 368func (*awsRestjson1_serializeOpCreateCoreDefinition) ID() string { 369 return "OperationSerializer" 370} 371 372func (m *awsRestjson1_serializeOpCreateCoreDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 373 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 374) { 375 request, ok := in.Request.(*smithyhttp.Request) 376 if !ok { 377 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 378 } 379 380 input, ok := in.Parameters.(*CreateCoreDefinitionInput) 381 _ = input 382 if !ok { 383 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 384 } 385 386 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores") 387 request.URL.Path = opPath 388 if len(request.URL.RawQuery) > 0 { 389 request.URL.RawQuery = "&" + opQuery 390 } else { 391 request.URL.RawQuery = opQuery 392 } 393 394 request.Method = "POST" 395 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 396 if err != nil { 397 return out, metadata, &smithy.SerializationError{Err: err} 398 } 399 400 if err := awsRestjson1_serializeOpHttpBindingsCreateCoreDefinitionInput(input, restEncoder); err != nil { 401 return out, metadata, &smithy.SerializationError{Err: err} 402 } 403 404 restEncoder.SetHeader("Content-Type").String("application/json") 405 406 jsonEncoder := smithyjson.NewEncoder() 407 if err := awsRestjson1_serializeOpDocumentCreateCoreDefinitionInput(input, jsonEncoder.Value); err != nil { 408 return out, metadata, &smithy.SerializationError{Err: err} 409 } 410 411 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 412 return out, metadata, &smithy.SerializationError{Err: err} 413 } 414 415 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 416 return out, metadata, &smithy.SerializationError{Err: err} 417 } 418 in.Request = request 419 420 return next.HandleSerialize(ctx, in) 421} 422func awsRestjson1_serializeOpHttpBindingsCreateCoreDefinitionInput(v *CreateCoreDefinitionInput, encoder *httpbinding.Encoder) error { 423 if v == nil { 424 return fmt.Errorf("unsupported serialization of nil %T", v) 425 } 426 427 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 428 locationName := "X-Amzn-Client-Token" 429 encoder.SetHeader(locationName).String(*v.AmznClientToken) 430 } 431 432 return nil 433} 434 435func awsRestjson1_serializeOpDocumentCreateCoreDefinitionInput(v *CreateCoreDefinitionInput, value smithyjson.Value) error { 436 object := value.Object() 437 defer object.Close() 438 439 if v.InitialVersion != nil { 440 ok := object.Key("InitialVersion") 441 if err := awsRestjson1_serializeDocumentCoreDefinitionVersion(v.InitialVersion, ok); err != nil { 442 return err 443 } 444 } 445 446 if v.Name != nil { 447 ok := object.Key("Name") 448 ok.String(*v.Name) 449 } 450 451 if v.Tags != nil { 452 ok := object.Key("tags") 453 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 454 return err 455 } 456 } 457 458 return nil 459} 460 461type awsRestjson1_serializeOpCreateCoreDefinitionVersion struct { 462} 463 464func (*awsRestjson1_serializeOpCreateCoreDefinitionVersion) ID() string { 465 return "OperationSerializer" 466} 467 468func (m *awsRestjson1_serializeOpCreateCoreDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 469 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 470) { 471 request, ok := in.Request.(*smithyhttp.Request) 472 if !ok { 473 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 474 } 475 476 input, ok := in.Parameters.(*CreateCoreDefinitionVersionInput) 477 _ = input 478 if !ok { 479 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 480 } 481 482 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}/versions") 483 request.URL.Path = opPath 484 if len(request.URL.RawQuery) > 0 { 485 request.URL.RawQuery = "&" + opQuery 486 } else { 487 request.URL.RawQuery = opQuery 488 } 489 490 request.Method = "POST" 491 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 492 if err != nil { 493 return out, metadata, &smithy.SerializationError{Err: err} 494 } 495 496 if err := awsRestjson1_serializeOpHttpBindingsCreateCoreDefinitionVersionInput(input, restEncoder); err != nil { 497 return out, metadata, &smithy.SerializationError{Err: err} 498 } 499 500 restEncoder.SetHeader("Content-Type").String("application/json") 501 502 jsonEncoder := smithyjson.NewEncoder() 503 if err := awsRestjson1_serializeOpDocumentCreateCoreDefinitionVersionInput(input, jsonEncoder.Value); err != nil { 504 return out, metadata, &smithy.SerializationError{Err: err} 505 } 506 507 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 508 return out, metadata, &smithy.SerializationError{Err: err} 509 } 510 511 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 512 return out, metadata, &smithy.SerializationError{Err: err} 513 } 514 in.Request = request 515 516 return next.HandleSerialize(ctx, in) 517} 518func awsRestjson1_serializeOpHttpBindingsCreateCoreDefinitionVersionInput(v *CreateCoreDefinitionVersionInput, encoder *httpbinding.Encoder) error { 519 if v == nil { 520 return fmt.Errorf("unsupported serialization of nil %T", v) 521 } 522 523 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 524 locationName := "X-Amzn-Client-Token" 525 encoder.SetHeader(locationName).String(*v.AmznClientToken) 526 } 527 528 if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 { 529 return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")} 530 } 531 if v.CoreDefinitionId != nil { 532 if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil { 533 return err 534 } 535 } 536 537 return nil 538} 539 540func awsRestjson1_serializeOpDocumentCreateCoreDefinitionVersionInput(v *CreateCoreDefinitionVersionInput, value smithyjson.Value) error { 541 object := value.Object() 542 defer object.Close() 543 544 if v.Cores != nil { 545 ok := object.Key("Cores") 546 if err := awsRestjson1_serializeDocument__listOfCore(v.Cores, ok); err != nil { 547 return err 548 } 549 } 550 551 return nil 552} 553 554type awsRestjson1_serializeOpCreateDeployment struct { 555} 556 557func (*awsRestjson1_serializeOpCreateDeployment) ID() string { 558 return "OperationSerializer" 559} 560 561func (m *awsRestjson1_serializeOpCreateDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 562 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 563) { 564 request, ok := in.Request.(*smithyhttp.Request) 565 if !ok { 566 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 567 } 568 569 input, ok := in.Parameters.(*CreateDeploymentInput) 570 _ = input 571 if !ok { 572 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 573 } 574 575 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/deployments") 576 request.URL.Path = opPath 577 if len(request.URL.RawQuery) > 0 { 578 request.URL.RawQuery = "&" + opQuery 579 } else { 580 request.URL.RawQuery = opQuery 581 } 582 583 request.Method = "POST" 584 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 585 if err != nil { 586 return out, metadata, &smithy.SerializationError{Err: err} 587 } 588 589 if err := awsRestjson1_serializeOpHttpBindingsCreateDeploymentInput(input, restEncoder); err != nil { 590 return out, metadata, &smithy.SerializationError{Err: err} 591 } 592 593 restEncoder.SetHeader("Content-Type").String("application/json") 594 595 jsonEncoder := smithyjson.NewEncoder() 596 if err := awsRestjson1_serializeOpDocumentCreateDeploymentInput(input, jsonEncoder.Value); err != nil { 597 return out, metadata, &smithy.SerializationError{Err: err} 598 } 599 600 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 601 return out, metadata, &smithy.SerializationError{Err: err} 602 } 603 604 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 605 return out, metadata, &smithy.SerializationError{Err: err} 606 } 607 in.Request = request 608 609 return next.HandleSerialize(ctx, in) 610} 611func awsRestjson1_serializeOpHttpBindingsCreateDeploymentInput(v *CreateDeploymentInput, encoder *httpbinding.Encoder) error { 612 if v == nil { 613 return fmt.Errorf("unsupported serialization of nil %T", v) 614 } 615 616 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 617 locationName := "X-Amzn-Client-Token" 618 encoder.SetHeader(locationName).String(*v.AmznClientToken) 619 } 620 621 if v.GroupId == nil || len(*v.GroupId) == 0 { 622 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 623 } 624 if v.GroupId != nil { 625 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 626 return err 627 } 628 } 629 630 return nil 631} 632 633func awsRestjson1_serializeOpDocumentCreateDeploymentInput(v *CreateDeploymentInput, value smithyjson.Value) error { 634 object := value.Object() 635 defer object.Close() 636 637 if v.DeploymentId != nil { 638 ok := object.Key("DeploymentId") 639 ok.String(*v.DeploymentId) 640 } 641 642 if len(v.DeploymentType) > 0 { 643 ok := object.Key("DeploymentType") 644 ok.String(string(v.DeploymentType)) 645 } 646 647 if v.GroupVersionId != nil { 648 ok := object.Key("GroupVersionId") 649 ok.String(*v.GroupVersionId) 650 } 651 652 return nil 653} 654 655type awsRestjson1_serializeOpCreateDeviceDefinition struct { 656} 657 658func (*awsRestjson1_serializeOpCreateDeviceDefinition) ID() string { 659 return "OperationSerializer" 660} 661 662func (m *awsRestjson1_serializeOpCreateDeviceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 663 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 664) { 665 request, ok := in.Request.(*smithyhttp.Request) 666 if !ok { 667 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 668 } 669 670 input, ok := in.Parameters.(*CreateDeviceDefinitionInput) 671 _ = input 672 if !ok { 673 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 674 } 675 676 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices") 677 request.URL.Path = opPath 678 if len(request.URL.RawQuery) > 0 { 679 request.URL.RawQuery = "&" + opQuery 680 } else { 681 request.URL.RawQuery = opQuery 682 } 683 684 request.Method = "POST" 685 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 686 if err != nil { 687 return out, metadata, &smithy.SerializationError{Err: err} 688 } 689 690 if err := awsRestjson1_serializeOpHttpBindingsCreateDeviceDefinitionInput(input, restEncoder); err != nil { 691 return out, metadata, &smithy.SerializationError{Err: err} 692 } 693 694 restEncoder.SetHeader("Content-Type").String("application/json") 695 696 jsonEncoder := smithyjson.NewEncoder() 697 if err := awsRestjson1_serializeOpDocumentCreateDeviceDefinitionInput(input, jsonEncoder.Value); err != nil { 698 return out, metadata, &smithy.SerializationError{Err: err} 699 } 700 701 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 702 return out, metadata, &smithy.SerializationError{Err: err} 703 } 704 705 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 706 return out, metadata, &smithy.SerializationError{Err: err} 707 } 708 in.Request = request 709 710 return next.HandleSerialize(ctx, in) 711} 712func awsRestjson1_serializeOpHttpBindingsCreateDeviceDefinitionInput(v *CreateDeviceDefinitionInput, encoder *httpbinding.Encoder) error { 713 if v == nil { 714 return fmt.Errorf("unsupported serialization of nil %T", v) 715 } 716 717 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 718 locationName := "X-Amzn-Client-Token" 719 encoder.SetHeader(locationName).String(*v.AmznClientToken) 720 } 721 722 return nil 723} 724 725func awsRestjson1_serializeOpDocumentCreateDeviceDefinitionInput(v *CreateDeviceDefinitionInput, value smithyjson.Value) error { 726 object := value.Object() 727 defer object.Close() 728 729 if v.InitialVersion != nil { 730 ok := object.Key("InitialVersion") 731 if err := awsRestjson1_serializeDocumentDeviceDefinitionVersion(v.InitialVersion, ok); err != nil { 732 return err 733 } 734 } 735 736 if v.Name != nil { 737 ok := object.Key("Name") 738 ok.String(*v.Name) 739 } 740 741 if v.Tags != nil { 742 ok := object.Key("tags") 743 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 744 return err 745 } 746 } 747 748 return nil 749} 750 751type awsRestjson1_serializeOpCreateDeviceDefinitionVersion struct { 752} 753 754func (*awsRestjson1_serializeOpCreateDeviceDefinitionVersion) ID() string { 755 return "OperationSerializer" 756} 757 758func (m *awsRestjson1_serializeOpCreateDeviceDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 759 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 760) { 761 request, ok := in.Request.(*smithyhttp.Request) 762 if !ok { 763 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 764 } 765 766 input, ok := in.Parameters.(*CreateDeviceDefinitionVersionInput) 767 _ = input 768 if !ok { 769 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 770 } 771 772 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}/versions") 773 request.URL.Path = opPath 774 if len(request.URL.RawQuery) > 0 { 775 request.URL.RawQuery = "&" + opQuery 776 } else { 777 request.URL.RawQuery = opQuery 778 } 779 780 request.Method = "POST" 781 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 782 if err != nil { 783 return out, metadata, &smithy.SerializationError{Err: err} 784 } 785 786 if err := awsRestjson1_serializeOpHttpBindingsCreateDeviceDefinitionVersionInput(input, restEncoder); err != nil { 787 return out, metadata, &smithy.SerializationError{Err: err} 788 } 789 790 restEncoder.SetHeader("Content-Type").String("application/json") 791 792 jsonEncoder := smithyjson.NewEncoder() 793 if err := awsRestjson1_serializeOpDocumentCreateDeviceDefinitionVersionInput(input, jsonEncoder.Value); err != nil { 794 return out, metadata, &smithy.SerializationError{Err: err} 795 } 796 797 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 798 return out, metadata, &smithy.SerializationError{Err: err} 799 } 800 801 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 802 return out, metadata, &smithy.SerializationError{Err: err} 803 } 804 in.Request = request 805 806 return next.HandleSerialize(ctx, in) 807} 808func awsRestjson1_serializeOpHttpBindingsCreateDeviceDefinitionVersionInput(v *CreateDeviceDefinitionVersionInput, encoder *httpbinding.Encoder) error { 809 if v == nil { 810 return fmt.Errorf("unsupported serialization of nil %T", v) 811 } 812 813 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 814 locationName := "X-Amzn-Client-Token" 815 encoder.SetHeader(locationName).String(*v.AmznClientToken) 816 } 817 818 if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 { 819 return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")} 820 } 821 if v.DeviceDefinitionId != nil { 822 if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil { 823 return err 824 } 825 } 826 827 return nil 828} 829 830func awsRestjson1_serializeOpDocumentCreateDeviceDefinitionVersionInput(v *CreateDeviceDefinitionVersionInput, value smithyjson.Value) error { 831 object := value.Object() 832 defer object.Close() 833 834 if v.Devices != nil { 835 ok := object.Key("Devices") 836 if err := awsRestjson1_serializeDocument__listOfDevice(v.Devices, ok); err != nil { 837 return err 838 } 839 } 840 841 return nil 842} 843 844type awsRestjson1_serializeOpCreateFunctionDefinition struct { 845} 846 847func (*awsRestjson1_serializeOpCreateFunctionDefinition) ID() string { 848 return "OperationSerializer" 849} 850 851func (m *awsRestjson1_serializeOpCreateFunctionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 852 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 853) { 854 request, ok := in.Request.(*smithyhttp.Request) 855 if !ok { 856 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 857 } 858 859 input, ok := in.Parameters.(*CreateFunctionDefinitionInput) 860 _ = input 861 if !ok { 862 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 863 } 864 865 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions") 866 request.URL.Path = opPath 867 if len(request.URL.RawQuery) > 0 { 868 request.URL.RawQuery = "&" + opQuery 869 } else { 870 request.URL.RawQuery = opQuery 871 } 872 873 request.Method = "POST" 874 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 875 if err != nil { 876 return out, metadata, &smithy.SerializationError{Err: err} 877 } 878 879 if err := awsRestjson1_serializeOpHttpBindingsCreateFunctionDefinitionInput(input, restEncoder); err != nil { 880 return out, metadata, &smithy.SerializationError{Err: err} 881 } 882 883 restEncoder.SetHeader("Content-Type").String("application/json") 884 885 jsonEncoder := smithyjson.NewEncoder() 886 if err := awsRestjson1_serializeOpDocumentCreateFunctionDefinitionInput(input, jsonEncoder.Value); err != nil { 887 return out, metadata, &smithy.SerializationError{Err: err} 888 } 889 890 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 891 return out, metadata, &smithy.SerializationError{Err: err} 892 } 893 894 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 895 return out, metadata, &smithy.SerializationError{Err: err} 896 } 897 in.Request = request 898 899 return next.HandleSerialize(ctx, in) 900} 901func awsRestjson1_serializeOpHttpBindingsCreateFunctionDefinitionInput(v *CreateFunctionDefinitionInput, encoder *httpbinding.Encoder) error { 902 if v == nil { 903 return fmt.Errorf("unsupported serialization of nil %T", v) 904 } 905 906 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 907 locationName := "X-Amzn-Client-Token" 908 encoder.SetHeader(locationName).String(*v.AmznClientToken) 909 } 910 911 return nil 912} 913 914func awsRestjson1_serializeOpDocumentCreateFunctionDefinitionInput(v *CreateFunctionDefinitionInput, value smithyjson.Value) error { 915 object := value.Object() 916 defer object.Close() 917 918 if v.InitialVersion != nil { 919 ok := object.Key("InitialVersion") 920 if err := awsRestjson1_serializeDocumentFunctionDefinitionVersion(v.InitialVersion, ok); err != nil { 921 return err 922 } 923 } 924 925 if v.Name != nil { 926 ok := object.Key("Name") 927 ok.String(*v.Name) 928 } 929 930 if v.Tags != nil { 931 ok := object.Key("tags") 932 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 933 return err 934 } 935 } 936 937 return nil 938} 939 940type awsRestjson1_serializeOpCreateFunctionDefinitionVersion struct { 941} 942 943func (*awsRestjson1_serializeOpCreateFunctionDefinitionVersion) ID() string { 944 return "OperationSerializer" 945} 946 947func (m *awsRestjson1_serializeOpCreateFunctionDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 948 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 949) { 950 request, ok := in.Request.(*smithyhttp.Request) 951 if !ok { 952 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 953 } 954 955 input, ok := in.Parameters.(*CreateFunctionDefinitionVersionInput) 956 _ = input 957 if !ok { 958 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 959 } 960 961 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}/versions") 962 request.URL.Path = opPath 963 if len(request.URL.RawQuery) > 0 { 964 request.URL.RawQuery = "&" + opQuery 965 } else { 966 request.URL.RawQuery = opQuery 967 } 968 969 request.Method = "POST" 970 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 971 if err != nil { 972 return out, metadata, &smithy.SerializationError{Err: err} 973 } 974 975 if err := awsRestjson1_serializeOpHttpBindingsCreateFunctionDefinitionVersionInput(input, restEncoder); err != nil { 976 return out, metadata, &smithy.SerializationError{Err: err} 977 } 978 979 restEncoder.SetHeader("Content-Type").String("application/json") 980 981 jsonEncoder := smithyjson.NewEncoder() 982 if err := awsRestjson1_serializeOpDocumentCreateFunctionDefinitionVersionInput(input, jsonEncoder.Value); err != nil { 983 return out, metadata, &smithy.SerializationError{Err: err} 984 } 985 986 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 987 return out, metadata, &smithy.SerializationError{Err: err} 988 } 989 990 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 991 return out, metadata, &smithy.SerializationError{Err: err} 992 } 993 in.Request = request 994 995 return next.HandleSerialize(ctx, in) 996} 997func awsRestjson1_serializeOpHttpBindingsCreateFunctionDefinitionVersionInput(v *CreateFunctionDefinitionVersionInput, encoder *httpbinding.Encoder) error { 998 if v == nil { 999 return fmt.Errorf("unsupported serialization of nil %T", v) 1000 } 1001 1002 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1003 locationName := "X-Amzn-Client-Token" 1004 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1005 } 1006 1007 if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 { 1008 return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")} 1009 } 1010 if v.FunctionDefinitionId != nil { 1011 if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil { 1012 return err 1013 } 1014 } 1015 1016 return nil 1017} 1018 1019func awsRestjson1_serializeOpDocumentCreateFunctionDefinitionVersionInput(v *CreateFunctionDefinitionVersionInput, value smithyjson.Value) error { 1020 object := value.Object() 1021 defer object.Close() 1022 1023 if v.DefaultConfig != nil { 1024 ok := object.Key("DefaultConfig") 1025 if err := awsRestjson1_serializeDocumentFunctionDefaultConfig(v.DefaultConfig, ok); err != nil { 1026 return err 1027 } 1028 } 1029 1030 if v.Functions != nil { 1031 ok := object.Key("Functions") 1032 if err := awsRestjson1_serializeDocument__listOfFunction(v.Functions, ok); err != nil { 1033 return err 1034 } 1035 } 1036 1037 return nil 1038} 1039 1040type awsRestjson1_serializeOpCreateGroup struct { 1041} 1042 1043func (*awsRestjson1_serializeOpCreateGroup) ID() string { 1044 return "OperationSerializer" 1045} 1046 1047func (m *awsRestjson1_serializeOpCreateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1048 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1049) { 1050 request, ok := in.Request.(*smithyhttp.Request) 1051 if !ok { 1052 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1053 } 1054 1055 input, ok := in.Parameters.(*CreateGroupInput) 1056 _ = input 1057 if !ok { 1058 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1059 } 1060 1061 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups") 1062 request.URL.Path = opPath 1063 if len(request.URL.RawQuery) > 0 { 1064 request.URL.RawQuery = "&" + opQuery 1065 } else { 1066 request.URL.RawQuery = opQuery 1067 } 1068 1069 request.Method = "POST" 1070 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1071 if err != nil { 1072 return out, metadata, &smithy.SerializationError{Err: err} 1073 } 1074 1075 if err := awsRestjson1_serializeOpHttpBindingsCreateGroupInput(input, restEncoder); err != nil { 1076 return out, metadata, &smithy.SerializationError{Err: err} 1077 } 1078 1079 restEncoder.SetHeader("Content-Type").String("application/json") 1080 1081 jsonEncoder := smithyjson.NewEncoder() 1082 if err := awsRestjson1_serializeOpDocumentCreateGroupInput(input, jsonEncoder.Value); err != nil { 1083 return out, metadata, &smithy.SerializationError{Err: err} 1084 } 1085 1086 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1087 return out, metadata, &smithy.SerializationError{Err: err} 1088 } 1089 1090 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1091 return out, metadata, &smithy.SerializationError{Err: err} 1092 } 1093 in.Request = request 1094 1095 return next.HandleSerialize(ctx, in) 1096} 1097func awsRestjson1_serializeOpHttpBindingsCreateGroupInput(v *CreateGroupInput, encoder *httpbinding.Encoder) error { 1098 if v == nil { 1099 return fmt.Errorf("unsupported serialization of nil %T", v) 1100 } 1101 1102 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1103 locationName := "X-Amzn-Client-Token" 1104 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1105 } 1106 1107 return nil 1108} 1109 1110func awsRestjson1_serializeOpDocumentCreateGroupInput(v *CreateGroupInput, value smithyjson.Value) error { 1111 object := value.Object() 1112 defer object.Close() 1113 1114 if v.InitialVersion != nil { 1115 ok := object.Key("InitialVersion") 1116 if err := awsRestjson1_serializeDocumentGroupVersion(v.InitialVersion, ok); err != nil { 1117 return err 1118 } 1119 } 1120 1121 if v.Name != nil { 1122 ok := object.Key("Name") 1123 ok.String(*v.Name) 1124 } 1125 1126 if v.Tags != nil { 1127 ok := object.Key("tags") 1128 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 1129 return err 1130 } 1131 } 1132 1133 return nil 1134} 1135 1136type awsRestjson1_serializeOpCreateGroupCertificateAuthority struct { 1137} 1138 1139func (*awsRestjson1_serializeOpCreateGroupCertificateAuthority) ID() string { 1140 return "OperationSerializer" 1141} 1142 1143func (m *awsRestjson1_serializeOpCreateGroupCertificateAuthority) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1144 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1145) { 1146 request, ok := in.Request.(*smithyhttp.Request) 1147 if !ok { 1148 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1149 } 1150 1151 input, ok := in.Parameters.(*CreateGroupCertificateAuthorityInput) 1152 _ = input 1153 if !ok { 1154 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1155 } 1156 1157 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities") 1158 request.URL.Path = opPath 1159 if len(request.URL.RawQuery) > 0 { 1160 request.URL.RawQuery = "&" + opQuery 1161 } else { 1162 request.URL.RawQuery = opQuery 1163 } 1164 1165 request.Method = "POST" 1166 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1167 if err != nil { 1168 return out, metadata, &smithy.SerializationError{Err: err} 1169 } 1170 1171 if err := awsRestjson1_serializeOpHttpBindingsCreateGroupCertificateAuthorityInput(input, restEncoder); err != nil { 1172 return out, metadata, &smithy.SerializationError{Err: err} 1173 } 1174 1175 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1176 return out, metadata, &smithy.SerializationError{Err: err} 1177 } 1178 in.Request = request 1179 1180 return next.HandleSerialize(ctx, in) 1181} 1182func awsRestjson1_serializeOpHttpBindingsCreateGroupCertificateAuthorityInput(v *CreateGroupCertificateAuthorityInput, encoder *httpbinding.Encoder) error { 1183 if v == nil { 1184 return fmt.Errorf("unsupported serialization of nil %T", v) 1185 } 1186 1187 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1188 locationName := "X-Amzn-Client-Token" 1189 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1190 } 1191 1192 if v.GroupId == nil || len(*v.GroupId) == 0 { 1193 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 1194 } 1195 if v.GroupId != nil { 1196 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 1197 return err 1198 } 1199 } 1200 1201 return nil 1202} 1203 1204type awsRestjson1_serializeOpCreateGroupVersion struct { 1205} 1206 1207func (*awsRestjson1_serializeOpCreateGroupVersion) ID() string { 1208 return "OperationSerializer" 1209} 1210 1211func (m *awsRestjson1_serializeOpCreateGroupVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1212 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1213) { 1214 request, ok := in.Request.(*smithyhttp.Request) 1215 if !ok { 1216 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1217 } 1218 1219 input, ok := in.Parameters.(*CreateGroupVersionInput) 1220 _ = input 1221 if !ok { 1222 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1223 } 1224 1225 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/versions") 1226 request.URL.Path = opPath 1227 if len(request.URL.RawQuery) > 0 { 1228 request.URL.RawQuery = "&" + opQuery 1229 } else { 1230 request.URL.RawQuery = opQuery 1231 } 1232 1233 request.Method = "POST" 1234 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1235 if err != nil { 1236 return out, metadata, &smithy.SerializationError{Err: err} 1237 } 1238 1239 if err := awsRestjson1_serializeOpHttpBindingsCreateGroupVersionInput(input, restEncoder); err != nil { 1240 return out, metadata, &smithy.SerializationError{Err: err} 1241 } 1242 1243 restEncoder.SetHeader("Content-Type").String("application/json") 1244 1245 jsonEncoder := smithyjson.NewEncoder() 1246 if err := awsRestjson1_serializeOpDocumentCreateGroupVersionInput(input, jsonEncoder.Value); err != nil { 1247 return out, metadata, &smithy.SerializationError{Err: err} 1248 } 1249 1250 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1251 return out, metadata, &smithy.SerializationError{Err: err} 1252 } 1253 1254 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1255 return out, metadata, &smithy.SerializationError{Err: err} 1256 } 1257 in.Request = request 1258 1259 return next.HandleSerialize(ctx, in) 1260} 1261func awsRestjson1_serializeOpHttpBindingsCreateGroupVersionInput(v *CreateGroupVersionInput, encoder *httpbinding.Encoder) error { 1262 if v == nil { 1263 return fmt.Errorf("unsupported serialization of nil %T", v) 1264 } 1265 1266 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1267 locationName := "X-Amzn-Client-Token" 1268 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1269 } 1270 1271 if v.GroupId == nil || len(*v.GroupId) == 0 { 1272 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 1273 } 1274 if v.GroupId != nil { 1275 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 1276 return err 1277 } 1278 } 1279 1280 return nil 1281} 1282 1283func awsRestjson1_serializeOpDocumentCreateGroupVersionInput(v *CreateGroupVersionInput, value smithyjson.Value) error { 1284 object := value.Object() 1285 defer object.Close() 1286 1287 if v.ConnectorDefinitionVersionArn != nil { 1288 ok := object.Key("ConnectorDefinitionVersionArn") 1289 ok.String(*v.ConnectorDefinitionVersionArn) 1290 } 1291 1292 if v.CoreDefinitionVersionArn != nil { 1293 ok := object.Key("CoreDefinitionVersionArn") 1294 ok.String(*v.CoreDefinitionVersionArn) 1295 } 1296 1297 if v.DeviceDefinitionVersionArn != nil { 1298 ok := object.Key("DeviceDefinitionVersionArn") 1299 ok.String(*v.DeviceDefinitionVersionArn) 1300 } 1301 1302 if v.FunctionDefinitionVersionArn != nil { 1303 ok := object.Key("FunctionDefinitionVersionArn") 1304 ok.String(*v.FunctionDefinitionVersionArn) 1305 } 1306 1307 if v.LoggerDefinitionVersionArn != nil { 1308 ok := object.Key("LoggerDefinitionVersionArn") 1309 ok.String(*v.LoggerDefinitionVersionArn) 1310 } 1311 1312 if v.ResourceDefinitionVersionArn != nil { 1313 ok := object.Key("ResourceDefinitionVersionArn") 1314 ok.String(*v.ResourceDefinitionVersionArn) 1315 } 1316 1317 if v.SubscriptionDefinitionVersionArn != nil { 1318 ok := object.Key("SubscriptionDefinitionVersionArn") 1319 ok.String(*v.SubscriptionDefinitionVersionArn) 1320 } 1321 1322 return nil 1323} 1324 1325type awsRestjson1_serializeOpCreateLoggerDefinition struct { 1326} 1327 1328func (*awsRestjson1_serializeOpCreateLoggerDefinition) ID() string { 1329 return "OperationSerializer" 1330} 1331 1332func (m *awsRestjson1_serializeOpCreateLoggerDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1333 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1334) { 1335 request, ok := in.Request.(*smithyhttp.Request) 1336 if !ok { 1337 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1338 } 1339 1340 input, ok := in.Parameters.(*CreateLoggerDefinitionInput) 1341 _ = input 1342 if !ok { 1343 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1344 } 1345 1346 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers") 1347 request.URL.Path = opPath 1348 if len(request.URL.RawQuery) > 0 { 1349 request.URL.RawQuery = "&" + opQuery 1350 } else { 1351 request.URL.RawQuery = opQuery 1352 } 1353 1354 request.Method = "POST" 1355 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1356 if err != nil { 1357 return out, metadata, &smithy.SerializationError{Err: err} 1358 } 1359 1360 if err := awsRestjson1_serializeOpHttpBindingsCreateLoggerDefinitionInput(input, restEncoder); err != nil { 1361 return out, metadata, &smithy.SerializationError{Err: err} 1362 } 1363 1364 restEncoder.SetHeader("Content-Type").String("application/json") 1365 1366 jsonEncoder := smithyjson.NewEncoder() 1367 if err := awsRestjson1_serializeOpDocumentCreateLoggerDefinitionInput(input, jsonEncoder.Value); err != nil { 1368 return out, metadata, &smithy.SerializationError{Err: err} 1369 } 1370 1371 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1372 return out, metadata, &smithy.SerializationError{Err: err} 1373 } 1374 1375 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1376 return out, metadata, &smithy.SerializationError{Err: err} 1377 } 1378 in.Request = request 1379 1380 return next.HandleSerialize(ctx, in) 1381} 1382func awsRestjson1_serializeOpHttpBindingsCreateLoggerDefinitionInput(v *CreateLoggerDefinitionInput, encoder *httpbinding.Encoder) error { 1383 if v == nil { 1384 return fmt.Errorf("unsupported serialization of nil %T", v) 1385 } 1386 1387 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1388 locationName := "X-Amzn-Client-Token" 1389 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1390 } 1391 1392 return nil 1393} 1394 1395func awsRestjson1_serializeOpDocumentCreateLoggerDefinitionInput(v *CreateLoggerDefinitionInput, value smithyjson.Value) error { 1396 object := value.Object() 1397 defer object.Close() 1398 1399 if v.InitialVersion != nil { 1400 ok := object.Key("InitialVersion") 1401 if err := awsRestjson1_serializeDocumentLoggerDefinitionVersion(v.InitialVersion, ok); err != nil { 1402 return err 1403 } 1404 } 1405 1406 if v.Name != nil { 1407 ok := object.Key("Name") 1408 ok.String(*v.Name) 1409 } 1410 1411 if v.Tags != nil { 1412 ok := object.Key("tags") 1413 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 1414 return err 1415 } 1416 } 1417 1418 return nil 1419} 1420 1421type awsRestjson1_serializeOpCreateLoggerDefinitionVersion struct { 1422} 1423 1424func (*awsRestjson1_serializeOpCreateLoggerDefinitionVersion) ID() string { 1425 return "OperationSerializer" 1426} 1427 1428func (m *awsRestjson1_serializeOpCreateLoggerDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1429 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1430) { 1431 request, ok := in.Request.(*smithyhttp.Request) 1432 if !ok { 1433 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1434 } 1435 1436 input, ok := in.Parameters.(*CreateLoggerDefinitionVersionInput) 1437 _ = input 1438 if !ok { 1439 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1440 } 1441 1442 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}/versions") 1443 request.URL.Path = opPath 1444 if len(request.URL.RawQuery) > 0 { 1445 request.URL.RawQuery = "&" + opQuery 1446 } else { 1447 request.URL.RawQuery = opQuery 1448 } 1449 1450 request.Method = "POST" 1451 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1452 if err != nil { 1453 return out, metadata, &smithy.SerializationError{Err: err} 1454 } 1455 1456 if err := awsRestjson1_serializeOpHttpBindingsCreateLoggerDefinitionVersionInput(input, restEncoder); err != nil { 1457 return out, metadata, &smithy.SerializationError{Err: err} 1458 } 1459 1460 restEncoder.SetHeader("Content-Type").String("application/json") 1461 1462 jsonEncoder := smithyjson.NewEncoder() 1463 if err := awsRestjson1_serializeOpDocumentCreateLoggerDefinitionVersionInput(input, jsonEncoder.Value); err != nil { 1464 return out, metadata, &smithy.SerializationError{Err: err} 1465 } 1466 1467 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1468 return out, metadata, &smithy.SerializationError{Err: err} 1469 } 1470 1471 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1472 return out, metadata, &smithy.SerializationError{Err: err} 1473 } 1474 in.Request = request 1475 1476 return next.HandleSerialize(ctx, in) 1477} 1478func awsRestjson1_serializeOpHttpBindingsCreateLoggerDefinitionVersionInput(v *CreateLoggerDefinitionVersionInput, encoder *httpbinding.Encoder) error { 1479 if v == nil { 1480 return fmt.Errorf("unsupported serialization of nil %T", v) 1481 } 1482 1483 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1484 locationName := "X-Amzn-Client-Token" 1485 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1486 } 1487 1488 if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 { 1489 return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")} 1490 } 1491 if v.LoggerDefinitionId != nil { 1492 if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil { 1493 return err 1494 } 1495 } 1496 1497 return nil 1498} 1499 1500func awsRestjson1_serializeOpDocumentCreateLoggerDefinitionVersionInput(v *CreateLoggerDefinitionVersionInput, value smithyjson.Value) error { 1501 object := value.Object() 1502 defer object.Close() 1503 1504 if v.Loggers != nil { 1505 ok := object.Key("Loggers") 1506 if err := awsRestjson1_serializeDocument__listOfLogger(v.Loggers, ok); err != nil { 1507 return err 1508 } 1509 } 1510 1511 return nil 1512} 1513 1514type awsRestjson1_serializeOpCreateResourceDefinition struct { 1515} 1516 1517func (*awsRestjson1_serializeOpCreateResourceDefinition) ID() string { 1518 return "OperationSerializer" 1519} 1520 1521func (m *awsRestjson1_serializeOpCreateResourceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1522 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1523) { 1524 request, ok := in.Request.(*smithyhttp.Request) 1525 if !ok { 1526 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1527 } 1528 1529 input, ok := in.Parameters.(*CreateResourceDefinitionInput) 1530 _ = input 1531 if !ok { 1532 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1533 } 1534 1535 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources") 1536 request.URL.Path = opPath 1537 if len(request.URL.RawQuery) > 0 { 1538 request.URL.RawQuery = "&" + opQuery 1539 } else { 1540 request.URL.RawQuery = opQuery 1541 } 1542 1543 request.Method = "POST" 1544 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1545 if err != nil { 1546 return out, metadata, &smithy.SerializationError{Err: err} 1547 } 1548 1549 if err := awsRestjson1_serializeOpHttpBindingsCreateResourceDefinitionInput(input, restEncoder); err != nil { 1550 return out, metadata, &smithy.SerializationError{Err: err} 1551 } 1552 1553 restEncoder.SetHeader("Content-Type").String("application/json") 1554 1555 jsonEncoder := smithyjson.NewEncoder() 1556 if err := awsRestjson1_serializeOpDocumentCreateResourceDefinitionInput(input, jsonEncoder.Value); err != nil { 1557 return out, metadata, &smithy.SerializationError{Err: err} 1558 } 1559 1560 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1561 return out, metadata, &smithy.SerializationError{Err: err} 1562 } 1563 1564 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1565 return out, metadata, &smithy.SerializationError{Err: err} 1566 } 1567 in.Request = request 1568 1569 return next.HandleSerialize(ctx, in) 1570} 1571func awsRestjson1_serializeOpHttpBindingsCreateResourceDefinitionInput(v *CreateResourceDefinitionInput, encoder *httpbinding.Encoder) error { 1572 if v == nil { 1573 return fmt.Errorf("unsupported serialization of nil %T", v) 1574 } 1575 1576 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1577 locationName := "X-Amzn-Client-Token" 1578 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1579 } 1580 1581 return nil 1582} 1583 1584func awsRestjson1_serializeOpDocumentCreateResourceDefinitionInput(v *CreateResourceDefinitionInput, value smithyjson.Value) error { 1585 object := value.Object() 1586 defer object.Close() 1587 1588 if v.InitialVersion != nil { 1589 ok := object.Key("InitialVersion") 1590 if err := awsRestjson1_serializeDocumentResourceDefinitionVersion(v.InitialVersion, ok); err != nil { 1591 return err 1592 } 1593 } 1594 1595 if v.Name != nil { 1596 ok := object.Key("Name") 1597 ok.String(*v.Name) 1598 } 1599 1600 if v.Tags != nil { 1601 ok := object.Key("tags") 1602 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 1603 return err 1604 } 1605 } 1606 1607 return nil 1608} 1609 1610type awsRestjson1_serializeOpCreateResourceDefinitionVersion struct { 1611} 1612 1613func (*awsRestjson1_serializeOpCreateResourceDefinitionVersion) ID() string { 1614 return "OperationSerializer" 1615} 1616 1617func (m *awsRestjson1_serializeOpCreateResourceDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1618 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1619) { 1620 request, ok := in.Request.(*smithyhttp.Request) 1621 if !ok { 1622 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1623 } 1624 1625 input, ok := in.Parameters.(*CreateResourceDefinitionVersionInput) 1626 _ = input 1627 if !ok { 1628 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1629 } 1630 1631 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}/versions") 1632 request.URL.Path = opPath 1633 if len(request.URL.RawQuery) > 0 { 1634 request.URL.RawQuery = "&" + opQuery 1635 } else { 1636 request.URL.RawQuery = opQuery 1637 } 1638 1639 request.Method = "POST" 1640 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1641 if err != nil { 1642 return out, metadata, &smithy.SerializationError{Err: err} 1643 } 1644 1645 if err := awsRestjson1_serializeOpHttpBindingsCreateResourceDefinitionVersionInput(input, restEncoder); err != nil { 1646 return out, metadata, &smithy.SerializationError{Err: err} 1647 } 1648 1649 restEncoder.SetHeader("Content-Type").String("application/json") 1650 1651 jsonEncoder := smithyjson.NewEncoder() 1652 if err := awsRestjson1_serializeOpDocumentCreateResourceDefinitionVersionInput(input, jsonEncoder.Value); err != nil { 1653 return out, metadata, &smithy.SerializationError{Err: err} 1654 } 1655 1656 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1657 return out, metadata, &smithy.SerializationError{Err: err} 1658 } 1659 1660 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1661 return out, metadata, &smithy.SerializationError{Err: err} 1662 } 1663 in.Request = request 1664 1665 return next.HandleSerialize(ctx, in) 1666} 1667func awsRestjson1_serializeOpHttpBindingsCreateResourceDefinitionVersionInput(v *CreateResourceDefinitionVersionInput, encoder *httpbinding.Encoder) error { 1668 if v == nil { 1669 return fmt.Errorf("unsupported serialization of nil %T", v) 1670 } 1671 1672 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1673 locationName := "X-Amzn-Client-Token" 1674 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1675 } 1676 1677 if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 { 1678 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")} 1679 } 1680 if v.ResourceDefinitionId != nil { 1681 if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil { 1682 return err 1683 } 1684 } 1685 1686 return nil 1687} 1688 1689func awsRestjson1_serializeOpDocumentCreateResourceDefinitionVersionInput(v *CreateResourceDefinitionVersionInput, value smithyjson.Value) error { 1690 object := value.Object() 1691 defer object.Close() 1692 1693 if v.Resources != nil { 1694 ok := object.Key("Resources") 1695 if err := awsRestjson1_serializeDocument__listOfResource(v.Resources, ok); err != nil { 1696 return err 1697 } 1698 } 1699 1700 return nil 1701} 1702 1703type awsRestjson1_serializeOpCreateSoftwareUpdateJob struct { 1704} 1705 1706func (*awsRestjson1_serializeOpCreateSoftwareUpdateJob) ID() string { 1707 return "OperationSerializer" 1708} 1709 1710func (m *awsRestjson1_serializeOpCreateSoftwareUpdateJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1711 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1712) { 1713 request, ok := in.Request.(*smithyhttp.Request) 1714 if !ok { 1715 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1716 } 1717 1718 input, ok := in.Parameters.(*CreateSoftwareUpdateJobInput) 1719 _ = input 1720 if !ok { 1721 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1722 } 1723 1724 opPath, opQuery := httpbinding.SplitURI("/greengrass/updates") 1725 request.URL.Path = opPath 1726 if len(request.URL.RawQuery) > 0 { 1727 request.URL.RawQuery = "&" + opQuery 1728 } else { 1729 request.URL.RawQuery = opQuery 1730 } 1731 1732 request.Method = "POST" 1733 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1734 if err != nil { 1735 return out, metadata, &smithy.SerializationError{Err: err} 1736 } 1737 1738 if err := awsRestjson1_serializeOpHttpBindingsCreateSoftwareUpdateJobInput(input, restEncoder); err != nil { 1739 return out, metadata, &smithy.SerializationError{Err: err} 1740 } 1741 1742 restEncoder.SetHeader("Content-Type").String("application/json") 1743 1744 jsonEncoder := smithyjson.NewEncoder() 1745 if err := awsRestjson1_serializeOpDocumentCreateSoftwareUpdateJobInput(input, jsonEncoder.Value); err != nil { 1746 return out, metadata, &smithy.SerializationError{Err: err} 1747 } 1748 1749 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1750 return out, metadata, &smithy.SerializationError{Err: err} 1751 } 1752 1753 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1754 return out, metadata, &smithy.SerializationError{Err: err} 1755 } 1756 in.Request = request 1757 1758 return next.HandleSerialize(ctx, in) 1759} 1760func awsRestjson1_serializeOpHttpBindingsCreateSoftwareUpdateJobInput(v *CreateSoftwareUpdateJobInput, encoder *httpbinding.Encoder) error { 1761 if v == nil { 1762 return fmt.Errorf("unsupported serialization of nil %T", v) 1763 } 1764 1765 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1766 locationName := "X-Amzn-Client-Token" 1767 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1768 } 1769 1770 return nil 1771} 1772 1773func awsRestjson1_serializeOpDocumentCreateSoftwareUpdateJobInput(v *CreateSoftwareUpdateJobInput, value smithyjson.Value) error { 1774 object := value.Object() 1775 defer object.Close() 1776 1777 if v.S3UrlSignerRole != nil { 1778 ok := object.Key("S3UrlSignerRole") 1779 ok.String(*v.S3UrlSignerRole) 1780 } 1781 1782 if len(v.SoftwareToUpdate) > 0 { 1783 ok := object.Key("SoftwareToUpdate") 1784 ok.String(string(v.SoftwareToUpdate)) 1785 } 1786 1787 if len(v.UpdateAgentLogLevel) > 0 { 1788 ok := object.Key("UpdateAgentLogLevel") 1789 ok.String(string(v.UpdateAgentLogLevel)) 1790 } 1791 1792 if v.UpdateTargets != nil { 1793 ok := object.Key("UpdateTargets") 1794 if err := awsRestjson1_serializeDocumentUpdateTargets(v.UpdateTargets, ok); err != nil { 1795 return err 1796 } 1797 } 1798 1799 if len(v.UpdateTargetsArchitecture) > 0 { 1800 ok := object.Key("UpdateTargetsArchitecture") 1801 ok.String(string(v.UpdateTargetsArchitecture)) 1802 } 1803 1804 if len(v.UpdateTargetsOperatingSystem) > 0 { 1805 ok := object.Key("UpdateTargetsOperatingSystem") 1806 ok.String(string(v.UpdateTargetsOperatingSystem)) 1807 } 1808 1809 return nil 1810} 1811 1812type awsRestjson1_serializeOpCreateSubscriptionDefinition struct { 1813} 1814 1815func (*awsRestjson1_serializeOpCreateSubscriptionDefinition) ID() string { 1816 return "OperationSerializer" 1817} 1818 1819func (m *awsRestjson1_serializeOpCreateSubscriptionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1820 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1821) { 1822 request, ok := in.Request.(*smithyhttp.Request) 1823 if !ok { 1824 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1825 } 1826 1827 input, ok := in.Parameters.(*CreateSubscriptionDefinitionInput) 1828 _ = input 1829 if !ok { 1830 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1831 } 1832 1833 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions") 1834 request.URL.Path = opPath 1835 if len(request.URL.RawQuery) > 0 { 1836 request.URL.RawQuery = "&" + opQuery 1837 } else { 1838 request.URL.RawQuery = opQuery 1839 } 1840 1841 request.Method = "POST" 1842 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1843 if err != nil { 1844 return out, metadata, &smithy.SerializationError{Err: err} 1845 } 1846 1847 if err := awsRestjson1_serializeOpHttpBindingsCreateSubscriptionDefinitionInput(input, restEncoder); err != nil { 1848 return out, metadata, &smithy.SerializationError{Err: err} 1849 } 1850 1851 restEncoder.SetHeader("Content-Type").String("application/json") 1852 1853 jsonEncoder := smithyjson.NewEncoder() 1854 if err := awsRestjson1_serializeOpDocumentCreateSubscriptionDefinitionInput(input, jsonEncoder.Value); err != nil { 1855 return out, metadata, &smithy.SerializationError{Err: err} 1856 } 1857 1858 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1859 return out, metadata, &smithy.SerializationError{Err: err} 1860 } 1861 1862 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1863 return out, metadata, &smithy.SerializationError{Err: err} 1864 } 1865 in.Request = request 1866 1867 return next.HandleSerialize(ctx, in) 1868} 1869func awsRestjson1_serializeOpHttpBindingsCreateSubscriptionDefinitionInput(v *CreateSubscriptionDefinitionInput, encoder *httpbinding.Encoder) error { 1870 if v == nil { 1871 return fmt.Errorf("unsupported serialization of nil %T", v) 1872 } 1873 1874 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1875 locationName := "X-Amzn-Client-Token" 1876 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1877 } 1878 1879 return nil 1880} 1881 1882func awsRestjson1_serializeOpDocumentCreateSubscriptionDefinitionInput(v *CreateSubscriptionDefinitionInput, value smithyjson.Value) error { 1883 object := value.Object() 1884 defer object.Close() 1885 1886 if v.InitialVersion != nil { 1887 ok := object.Key("InitialVersion") 1888 if err := awsRestjson1_serializeDocumentSubscriptionDefinitionVersion(v.InitialVersion, ok); err != nil { 1889 return err 1890 } 1891 } 1892 1893 if v.Name != nil { 1894 ok := object.Key("Name") 1895 ok.String(*v.Name) 1896 } 1897 1898 if v.Tags != nil { 1899 ok := object.Key("tags") 1900 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 1901 return err 1902 } 1903 } 1904 1905 return nil 1906} 1907 1908type awsRestjson1_serializeOpCreateSubscriptionDefinitionVersion struct { 1909} 1910 1911func (*awsRestjson1_serializeOpCreateSubscriptionDefinitionVersion) ID() string { 1912 return "OperationSerializer" 1913} 1914 1915func (m *awsRestjson1_serializeOpCreateSubscriptionDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1916 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1917) { 1918 request, ok := in.Request.(*smithyhttp.Request) 1919 if !ok { 1920 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1921 } 1922 1923 input, ok := in.Parameters.(*CreateSubscriptionDefinitionVersionInput) 1924 _ = input 1925 if !ok { 1926 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1927 } 1928 1929 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions") 1930 request.URL.Path = opPath 1931 if len(request.URL.RawQuery) > 0 { 1932 request.URL.RawQuery = "&" + opQuery 1933 } else { 1934 request.URL.RawQuery = opQuery 1935 } 1936 1937 request.Method = "POST" 1938 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1939 if err != nil { 1940 return out, metadata, &smithy.SerializationError{Err: err} 1941 } 1942 1943 if err := awsRestjson1_serializeOpHttpBindingsCreateSubscriptionDefinitionVersionInput(input, restEncoder); err != nil { 1944 return out, metadata, &smithy.SerializationError{Err: err} 1945 } 1946 1947 restEncoder.SetHeader("Content-Type").String("application/json") 1948 1949 jsonEncoder := smithyjson.NewEncoder() 1950 if err := awsRestjson1_serializeOpDocumentCreateSubscriptionDefinitionVersionInput(input, jsonEncoder.Value); err != nil { 1951 return out, metadata, &smithy.SerializationError{Err: err} 1952 } 1953 1954 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1955 return out, metadata, &smithy.SerializationError{Err: err} 1956 } 1957 1958 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1959 return out, metadata, &smithy.SerializationError{Err: err} 1960 } 1961 in.Request = request 1962 1963 return next.HandleSerialize(ctx, in) 1964} 1965func awsRestjson1_serializeOpHttpBindingsCreateSubscriptionDefinitionVersionInput(v *CreateSubscriptionDefinitionVersionInput, encoder *httpbinding.Encoder) error { 1966 if v == nil { 1967 return fmt.Errorf("unsupported serialization of nil %T", v) 1968 } 1969 1970 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 1971 locationName := "X-Amzn-Client-Token" 1972 encoder.SetHeader(locationName).String(*v.AmznClientToken) 1973 } 1974 1975 if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 { 1976 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")} 1977 } 1978 if v.SubscriptionDefinitionId != nil { 1979 if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil { 1980 return err 1981 } 1982 } 1983 1984 return nil 1985} 1986 1987func awsRestjson1_serializeOpDocumentCreateSubscriptionDefinitionVersionInput(v *CreateSubscriptionDefinitionVersionInput, value smithyjson.Value) error { 1988 object := value.Object() 1989 defer object.Close() 1990 1991 if v.Subscriptions != nil { 1992 ok := object.Key("Subscriptions") 1993 if err := awsRestjson1_serializeDocument__listOfSubscription(v.Subscriptions, ok); err != nil { 1994 return err 1995 } 1996 } 1997 1998 return nil 1999} 2000 2001type awsRestjson1_serializeOpDeleteConnectorDefinition struct { 2002} 2003 2004func (*awsRestjson1_serializeOpDeleteConnectorDefinition) ID() string { 2005 return "OperationSerializer" 2006} 2007 2008func (m *awsRestjson1_serializeOpDeleteConnectorDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2009 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2010) { 2011 request, ok := in.Request.(*smithyhttp.Request) 2012 if !ok { 2013 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2014 } 2015 2016 input, ok := in.Parameters.(*DeleteConnectorDefinitionInput) 2017 _ = input 2018 if !ok { 2019 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2020 } 2021 2022 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}") 2023 request.URL.Path = opPath 2024 if len(request.URL.RawQuery) > 0 { 2025 request.URL.RawQuery = "&" + opQuery 2026 } else { 2027 request.URL.RawQuery = opQuery 2028 } 2029 2030 request.Method = "DELETE" 2031 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2032 if err != nil { 2033 return out, metadata, &smithy.SerializationError{Err: err} 2034 } 2035 2036 if err := awsRestjson1_serializeOpHttpBindingsDeleteConnectorDefinitionInput(input, restEncoder); err != nil { 2037 return out, metadata, &smithy.SerializationError{Err: err} 2038 } 2039 2040 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2041 return out, metadata, &smithy.SerializationError{Err: err} 2042 } 2043 in.Request = request 2044 2045 return next.HandleSerialize(ctx, in) 2046} 2047func awsRestjson1_serializeOpHttpBindingsDeleteConnectorDefinitionInput(v *DeleteConnectorDefinitionInput, encoder *httpbinding.Encoder) error { 2048 if v == nil { 2049 return fmt.Errorf("unsupported serialization of nil %T", v) 2050 } 2051 2052 if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 { 2053 return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")} 2054 } 2055 if v.ConnectorDefinitionId != nil { 2056 if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil { 2057 return err 2058 } 2059 } 2060 2061 return nil 2062} 2063 2064type awsRestjson1_serializeOpDeleteCoreDefinition struct { 2065} 2066 2067func (*awsRestjson1_serializeOpDeleteCoreDefinition) ID() string { 2068 return "OperationSerializer" 2069} 2070 2071func (m *awsRestjson1_serializeOpDeleteCoreDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2072 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2073) { 2074 request, ok := in.Request.(*smithyhttp.Request) 2075 if !ok { 2076 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2077 } 2078 2079 input, ok := in.Parameters.(*DeleteCoreDefinitionInput) 2080 _ = input 2081 if !ok { 2082 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2083 } 2084 2085 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}") 2086 request.URL.Path = opPath 2087 if len(request.URL.RawQuery) > 0 { 2088 request.URL.RawQuery = "&" + opQuery 2089 } else { 2090 request.URL.RawQuery = opQuery 2091 } 2092 2093 request.Method = "DELETE" 2094 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2095 if err != nil { 2096 return out, metadata, &smithy.SerializationError{Err: err} 2097 } 2098 2099 if err := awsRestjson1_serializeOpHttpBindingsDeleteCoreDefinitionInput(input, restEncoder); err != nil { 2100 return out, metadata, &smithy.SerializationError{Err: err} 2101 } 2102 2103 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2104 return out, metadata, &smithy.SerializationError{Err: err} 2105 } 2106 in.Request = request 2107 2108 return next.HandleSerialize(ctx, in) 2109} 2110func awsRestjson1_serializeOpHttpBindingsDeleteCoreDefinitionInput(v *DeleteCoreDefinitionInput, encoder *httpbinding.Encoder) error { 2111 if v == nil { 2112 return fmt.Errorf("unsupported serialization of nil %T", v) 2113 } 2114 2115 if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 { 2116 return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")} 2117 } 2118 if v.CoreDefinitionId != nil { 2119 if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil { 2120 return err 2121 } 2122 } 2123 2124 return nil 2125} 2126 2127type awsRestjson1_serializeOpDeleteDeviceDefinition struct { 2128} 2129 2130func (*awsRestjson1_serializeOpDeleteDeviceDefinition) ID() string { 2131 return "OperationSerializer" 2132} 2133 2134func (m *awsRestjson1_serializeOpDeleteDeviceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2135 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2136) { 2137 request, ok := in.Request.(*smithyhttp.Request) 2138 if !ok { 2139 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2140 } 2141 2142 input, ok := in.Parameters.(*DeleteDeviceDefinitionInput) 2143 _ = input 2144 if !ok { 2145 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2146 } 2147 2148 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}") 2149 request.URL.Path = opPath 2150 if len(request.URL.RawQuery) > 0 { 2151 request.URL.RawQuery = "&" + opQuery 2152 } else { 2153 request.URL.RawQuery = opQuery 2154 } 2155 2156 request.Method = "DELETE" 2157 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2158 if err != nil { 2159 return out, metadata, &smithy.SerializationError{Err: err} 2160 } 2161 2162 if err := awsRestjson1_serializeOpHttpBindingsDeleteDeviceDefinitionInput(input, restEncoder); err != nil { 2163 return out, metadata, &smithy.SerializationError{Err: err} 2164 } 2165 2166 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2167 return out, metadata, &smithy.SerializationError{Err: err} 2168 } 2169 in.Request = request 2170 2171 return next.HandleSerialize(ctx, in) 2172} 2173func awsRestjson1_serializeOpHttpBindingsDeleteDeviceDefinitionInput(v *DeleteDeviceDefinitionInput, encoder *httpbinding.Encoder) error { 2174 if v == nil { 2175 return fmt.Errorf("unsupported serialization of nil %T", v) 2176 } 2177 2178 if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 { 2179 return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")} 2180 } 2181 if v.DeviceDefinitionId != nil { 2182 if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil { 2183 return err 2184 } 2185 } 2186 2187 return nil 2188} 2189 2190type awsRestjson1_serializeOpDeleteFunctionDefinition struct { 2191} 2192 2193func (*awsRestjson1_serializeOpDeleteFunctionDefinition) ID() string { 2194 return "OperationSerializer" 2195} 2196 2197func (m *awsRestjson1_serializeOpDeleteFunctionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2198 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2199) { 2200 request, ok := in.Request.(*smithyhttp.Request) 2201 if !ok { 2202 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2203 } 2204 2205 input, ok := in.Parameters.(*DeleteFunctionDefinitionInput) 2206 _ = input 2207 if !ok { 2208 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2209 } 2210 2211 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}") 2212 request.URL.Path = opPath 2213 if len(request.URL.RawQuery) > 0 { 2214 request.URL.RawQuery = "&" + opQuery 2215 } else { 2216 request.URL.RawQuery = opQuery 2217 } 2218 2219 request.Method = "DELETE" 2220 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2221 if err != nil { 2222 return out, metadata, &smithy.SerializationError{Err: err} 2223 } 2224 2225 if err := awsRestjson1_serializeOpHttpBindingsDeleteFunctionDefinitionInput(input, restEncoder); err != nil { 2226 return out, metadata, &smithy.SerializationError{Err: err} 2227 } 2228 2229 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2230 return out, metadata, &smithy.SerializationError{Err: err} 2231 } 2232 in.Request = request 2233 2234 return next.HandleSerialize(ctx, in) 2235} 2236func awsRestjson1_serializeOpHttpBindingsDeleteFunctionDefinitionInput(v *DeleteFunctionDefinitionInput, encoder *httpbinding.Encoder) error { 2237 if v == nil { 2238 return fmt.Errorf("unsupported serialization of nil %T", v) 2239 } 2240 2241 if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 { 2242 return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")} 2243 } 2244 if v.FunctionDefinitionId != nil { 2245 if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil { 2246 return err 2247 } 2248 } 2249 2250 return nil 2251} 2252 2253type awsRestjson1_serializeOpDeleteGroup struct { 2254} 2255 2256func (*awsRestjson1_serializeOpDeleteGroup) ID() string { 2257 return "OperationSerializer" 2258} 2259 2260func (m *awsRestjson1_serializeOpDeleteGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2261 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2262) { 2263 request, ok := in.Request.(*smithyhttp.Request) 2264 if !ok { 2265 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2266 } 2267 2268 input, ok := in.Parameters.(*DeleteGroupInput) 2269 _ = input 2270 if !ok { 2271 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2272 } 2273 2274 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}") 2275 request.URL.Path = opPath 2276 if len(request.URL.RawQuery) > 0 { 2277 request.URL.RawQuery = "&" + opQuery 2278 } else { 2279 request.URL.RawQuery = opQuery 2280 } 2281 2282 request.Method = "DELETE" 2283 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2284 if err != nil { 2285 return out, metadata, &smithy.SerializationError{Err: err} 2286 } 2287 2288 if err := awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(input, restEncoder); err != nil { 2289 return out, metadata, &smithy.SerializationError{Err: err} 2290 } 2291 2292 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2293 return out, metadata, &smithy.SerializationError{Err: err} 2294 } 2295 in.Request = request 2296 2297 return next.HandleSerialize(ctx, in) 2298} 2299func awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(v *DeleteGroupInput, encoder *httpbinding.Encoder) error { 2300 if v == nil { 2301 return fmt.Errorf("unsupported serialization of nil %T", v) 2302 } 2303 2304 if v.GroupId == nil || len(*v.GroupId) == 0 { 2305 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 2306 } 2307 if v.GroupId != nil { 2308 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 2309 return err 2310 } 2311 } 2312 2313 return nil 2314} 2315 2316type awsRestjson1_serializeOpDeleteLoggerDefinition struct { 2317} 2318 2319func (*awsRestjson1_serializeOpDeleteLoggerDefinition) ID() string { 2320 return "OperationSerializer" 2321} 2322 2323func (m *awsRestjson1_serializeOpDeleteLoggerDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2324 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2325) { 2326 request, ok := in.Request.(*smithyhttp.Request) 2327 if !ok { 2328 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2329 } 2330 2331 input, ok := in.Parameters.(*DeleteLoggerDefinitionInput) 2332 _ = input 2333 if !ok { 2334 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2335 } 2336 2337 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}") 2338 request.URL.Path = opPath 2339 if len(request.URL.RawQuery) > 0 { 2340 request.URL.RawQuery = "&" + opQuery 2341 } else { 2342 request.URL.RawQuery = opQuery 2343 } 2344 2345 request.Method = "DELETE" 2346 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2347 if err != nil { 2348 return out, metadata, &smithy.SerializationError{Err: err} 2349 } 2350 2351 if err := awsRestjson1_serializeOpHttpBindingsDeleteLoggerDefinitionInput(input, restEncoder); err != nil { 2352 return out, metadata, &smithy.SerializationError{Err: err} 2353 } 2354 2355 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2356 return out, metadata, &smithy.SerializationError{Err: err} 2357 } 2358 in.Request = request 2359 2360 return next.HandleSerialize(ctx, in) 2361} 2362func awsRestjson1_serializeOpHttpBindingsDeleteLoggerDefinitionInput(v *DeleteLoggerDefinitionInput, encoder *httpbinding.Encoder) error { 2363 if v == nil { 2364 return fmt.Errorf("unsupported serialization of nil %T", v) 2365 } 2366 2367 if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 { 2368 return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")} 2369 } 2370 if v.LoggerDefinitionId != nil { 2371 if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil { 2372 return err 2373 } 2374 } 2375 2376 return nil 2377} 2378 2379type awsRestjson1_serializeOpDeleteResourceDefinition struct { 2380} 2381 2382func (*awsRestjson1_serializeOpDeleteResourceDefinition) ID() string { 2383 return "OperationSerializer" 2384} 2385 2386func (m *awsRestjson1_serializeOpDeleteResourceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2387 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2388) { 2389 request, ok := in.Request.(*smithyhttp.Request) 2390 if !ok { 2391 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2392 } 2393 2394 input, ok := in.Parameters.(*DeleteResourceDefinitionInput) 2395 _ = input 2396 if !ok { 2397 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2398 } 2399 2400 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}") 2401 request.URL.Path = opPath 2402 if len(request.URL.RawQuery) > 0 { 2403 request.URL.RawQuery = "&" + opQuery 2404 } else { 2405 request.URL.RawQuery = opQuery 2406 } 2407 2408 request.Method = "DELETE" 2409 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2410 if err != nil { 2411 return out, metadata, &smithy.SerializationError{Err: err} 2412 } 2413 2414 if err := awsRestjson1_serializeOpHttpBindingsDeleteResourceDefinitionInput(input, restEncoder); err != nil { 2415 return out, metadata, &smithy.SerializationError{Err: err} 2416 } 2417 2418 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2419 return out, metadata, &smithy.SerializationError{Err: err} 2420 } 2421 in.Request = request 2422 2423 return next.HandleSerialize(ctx, in) 2424} 2425func awsRestjson1_serializeOpHttpBindingsDeleteResourceDefinitionInput(v *DeleteResourceDefinitionInput, encoder *httpbinding.Encoder) error { 2426 if v == nil { 2427 return fmt.Errorf("unsupported serialization of nil %T", v) 2428 } 2429 2430 if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 { 2431 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")} 2432 } 2433 if v.ResourceDefinitionId != nil { 2434 if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil { 2435 return err 2436 } 2437 } 2438 2439 return nil 2440} 2441 2442type awsRestjson1_serializeOpDeleteSubscriptionDefinition struct { 2443} 2444 2445func (*awsRestjson1_serializeOpDeleteSubscriptionDefinition) ID() string { 2446 return "OperationSerializer" 2447} 2448 2449func (m *awsRestjson1_serializeOpDeleteSubscriptionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2450 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2451) { 2452 request, ok := in.Request.(*smithyhttp.Request) 2453 if !ok { 2454 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2455 } 2456 2457 input, ok := in.Parameters.(*DeleteSubscriptionDefinitionInput) 2458 _ = input 2459 if !ok { 2460 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2461 } 2462 2463 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}") 2464 request.URL.Path = opPath 2465 if len(request.URL.RawQuery) > 0 { 2466 request.URL.RawQuery = "&" + opQuery 2467 } else { 2468 request.URL.RawQuery = opQuery 2469 } 2470 2471 request.Method = "DELETE" 2472 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2473 if err != nil { 2474 return out, metadata, &smithy.SerializationError{Err: err} 2475 } 2476 2477 if err := awsRestjson1_serializeOpHttpBindingsDeleteSubscriptionDefinitionInput(input, restEncoder); err != nil { 2478 return out, metadata, &smithy.SerializationError{Err: err} 2479 } 2480 2481 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2482 return out, metadata, &smithy.SerializationError{Err: err} 2483 } 2484 in.Request = request 2485 2486 return next.HandleSerialize(ctx, in) 2487} 2488func awsRestjson1_serializeOpHttpBindingsDeleteSubscriptionDefinitionInput(v *DeleteSubscriptionDefinitionInput, encoder *httpbinding.Encoder) error { 2489 if v == nil { 2490 return fmt.Errorf("unsupported serialization of nil %T", v) 2491 } 2492 2493 if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 { 2494 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")} 2495 } 2496 if v.SubscriptionDefinitionId != nil { 2497 if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil { 2498 return err 2499 } 2500 } 2501 2502 return nil 2503} 2504 2505type awsRestjson1_serializeOpDisassociateRoleFromGroup struct { 2506} 2507 2508func (*awsRestjson1_serializeOpDisassociateRoleFromGroup) ID() string { 2509 return "OperationSerializer" 2510} 2511 2512func (m *awsRestjson1_serializeOpDisassociateRoleFromGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2513 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2514) { 2515 request, ok := in.Request.(*smithyhttp.Request) 2516 if !ok { 2517 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2518 } 2519 2520 input, ok := in.Parameters.(*DisassociateRoleFromGroupInput) 2521 _ = input 2522 if !ok { 2523 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2524 } 2525 2526 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/role") 2527 request.URL.Path = opPath 2528 if len(request.URL.RawQuery) > 0 { 2529 request.URL.RawQuery = "&" + opQuery 2530 } else { 2531 request.URL.RawQuery = opQuery 2532 } 2533 2534 request.Method = "DELETE" 2535 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2536 if err != nil { 2537 return out, metadata, &smithy.SerializationError{Err: err} 2538 } 2539 2540 if err := awsRestjson1_serializeOpHttpBindingsDisassociateRoleFromGroupInput(input, restEncoder); err != nil { 2541 return out, metadata, &smithy.SerializationError{Err: err} 2542 } 2543 2544 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2545 return out, metadata, &smithy.SerializationError{Err: err} 2546 } 2547 in.Request = request 2548 2549 return next.HandleSerialize(ctx, in) 2550} 2551func awsRestjson1_serializeOpHttpBindingsDisassociateRoleFromGroupInput(v *DisassociateRoleFromGroupInput, encoder *httpbinding.Encoder) error { 2552 if v == nil { 2553 return fmt.Errorf("unsupported serialization of nil %T", v) 2554 } 2555 2556 if v.GroupId == nil || len(*v.GroupId) == 0 { 2557 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 2558 } 2559 if v.GroupId != nil { 2560 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 2561 return err 2562 } 2563 } 2564 2565 return nil 2566} 2567 2568type awsRestjson1_serializeOpDisassociateServiceRoleFromAccount struct { 2569} 2570 2571func (*awsRestjson1_serializeOpDisassociateServiceRoleFromAccount) ID() string { 2572 return "OperationSerializer" 2573} 2574 2575func (m *awsRestjson1_serializeOpDisassociateServiceRoleFromAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2576 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2577) { 2578 request, ok := in.Request.(*smithyhttp.Request) 2579 if !ok { 2580 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2581 } 2582 2583 input, ok := in.Parameters.(*DisassociateServiceRoleFromAccountInput) 2584 _ = input 2585 if !ok { 2586 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2587 } 2588 2589 opPath, opQuery := httpbinding.SplitURI("/greengrass/servicerole") 2590 request.URL.Path = opPath 2591 if len(request.URL.RawQuery) > 0 { 2592 request.URL.RawQuery = "&" + opQuery 2593 } else { 2594 request.URL.RawQuery = opQuery 2595 } 2596 2597 request.Method = "DELETE" 2598 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2599 if err != nil { 2600 return out, metadata, &smithy.SerializationError{Err: err} 2601 } 2602 2603 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2604 return out, metadata, &smithy.SerializationError{Err: err} 2605 } 2606 in.Request = request 2607 2608 return next.HandleSerialize(ctx, in) 2609} 2610func awsRestjson1_serializeOpHttpBindingsDisassociateServiceRoleFromAccountInput(v *DisassociateServiceRoleFromAccountInput, encoder *httpbinding.Encoder) error { 2611 if v == nil { 2612 return fmt.Errorf("unsupported serialization of nil %T", v) 2613 } 2614 2615 return nil 2616} 2617 2618type awsRestjson1_serializeOpGetAssociatedRole struct { 2619} 2620 2621func (*awsRestjson1_serializeOpGetAssociatedRole) ID() string { 2622 return "OperationSerializer" 2623} 2624 2625func (m *awsRestjson1_serializeOpGetAssociatedRole) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2626 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2627) { 2628 request, ok := in.Request.(*smithyhttp.Request) 2629 if !ok { 2630 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2631 } 2632 2633 input, ok := in.Parameters.(*GetAssociatedRoleInput) 2634 _ = input 2635 if !ok { 2636 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2637 } 2638 2639 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/role") 2640 request.URL.Path = opPath 2641 if len(request.URL.RawQuery) > 0 { 2642 request.URL.RawQuery = "&" + opQuery 2643 } else { 2644 request.URL.RawQuery = opQuery 2645 } 2646 2647 request.Method = "GET" 2648 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2649 if err != nil { 2650 return out, metadata, &smithy.SerializationError{Err: err} 2651 } 2652 2653 if err := awsRestjson1_serializeOpHttpBindingsGetAssociatedRoleInput(input, restEncoder); err != nil { 2654 return out, metadata, &smithy.SerializationError{Err: err} 2655 } 2656 2657 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2658 return out, metadata, &smithy.SerializationError{Err: err} 2659 } 2660 in.Request = request 2661 2662 return next.HandleSerialize(ctx, in) 2663} 2664func awsRestjson1_serializeOpHttpBindingsGetAssociatedRoleInput(v *GetAssociatedRoleInput, encoder *httpbinding.Encoder) error { 2665 if v == nil { 2666 return fmt.Errorf("unsupported serialization of nil %T", v) 2667 } 2668 2669 if v.GroupId == nil || len(*v.GroupId) == 0 { 2670 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 2671 } 2672 if v.GroupId != nil { 2673 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 2674 return err 2675 } 2676 } 2677 2678 return nil 2679} 2680 2681type awsRestjson1_serializeOpGetBulkDeploymentStatus struct { 2682} 2683 2684func (*awsRestjson1_serializeOpGetBulkDeploymentStatus) ID() string { 2685 return "OperationSerializer" 2686} 2687 2688func (m *awsRestjson1_serializeOpGetBulkDeploymentStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2689 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2690) { 2691 request, ok := in.Request.(*smithyhttp.Request) 2692 if !ok { 2693 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2694 } 2695 2696 input, ok := in.Parameters.(*GetBulkDeploymentStatusInput) 2697 _ = input 2698 if !ok { 2699 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2700 } 2701 2702 opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments/{BulkDeploymentId}/status") 2703 request.URL.Path = opPath 2704 if len(request.URL.RawQuery) > 0 { 2705 request.URL.RawQuery = "&" + opQuery 2706 } else { 2707 request.URL.RawQuery = opQuery 2708 } 2709 2710 request.Method = "GET" 2711 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2712 if err != nil { 2713 return out, metadata, &smithy.SerializationError{Err: err} 2714 } 2715 2716 if err := awsRestjson1_serializeOpHttpBindingsGetBulkDeploymentStatusInput(input, restEncoder); err != nil { 2717 return out, metadata, &smithy.SerializationError{Err: err} 2718 } 2719 2720 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2721 return out, metadata, &smithy.SerializationError{Err: err} 2722 } 2723 in.Request = request 2724 2725 return next.HandleSerialize(ctx, in) 2726} 2727func awsRestjson1_serializeOpHttpBindingsGetBulkDeploymentStatusInput(v *GetBulkDeploymentStatusInput, encoder *httpbinding.Encoder) error { 2728 if v == nil { 2729 return fmt.Errorf("unsupported serialization of nil %T", v) 2730 } 2731 2732 if v.BulkDeploymentId == nil || len(*v.BulkDeploymentId) == 0 { 2733 return &smithy.SerializationError{Err: fmt.Errorf("input member BulkDeploymentId must not be empty")} 2734 } 2735 if v.BulkDeploymentId != nil { 2736 if err := encoder.SetURI("BulkDeploymentId").String(*v.BulkDeploymentId); err != nil { 2737 return err 2738 } 2739 } 2740 2741 return nil 2742} 2743 2744type awsRestjson1_serializeOpGetConnectivityInfo struct { 2745} 2746 2747func (*awsRestjson1_serializeOpGetConnectivityInfo) ID() string { 2748 return "OperationSerializer" 2749} 2750 2751func (m *awsRestjson1_serializeOpGetConnectivityInfo) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2752 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2753) { 2754 request, ok := in.Request.(*smithyhttp.Request) 2755 if !ok { 2756 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2757 } 2758 2759 input, ok := in.Parameters.(*GetConnectivityInfoInput) 2760 _ = input 2761 if !ok { 2762 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2763 } 2764 2765 opPath, opQuery := httpbinding.SplitURI("/greengrass/things/{ThingName}/connectivityInfo") 2766 request.URL.Path = opPath 2767 if len(request.URL.RawQuery) > 0 { 2768 request.URL.RawQuery = "&" + opQuery 2769 } else { 2770 request.URL.RawQuery = opQuery 2771 } 2772 2773 request.Method = "GET" 2774 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2775 if err != nil { 2776 return out, metadata, &smithy.SerializationError{Err: err} 2777 } 2778 2779 if err := awsRestjson1_serializeOpHttpBindingsGetConnectivityInfoInput(input, restEncoder); err != nil { 2780 return out, metadata, &smithy.SerializationError{Err: err} 2781 } 2782 2783 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2784 return out, metadata, &smithy.SerializationError{Err: err} 2785 } 2786 in.Request = request 2787 2788 return next.HandleSerialize(ctx, in) 2789} 2790func awsRestjson1_serializeOpHttpBindingsGetConnectivityInfoInput(v *GetConnectivityInfoInput, encoder *httpbinding.Encoder) error { 2791 if v == nil { 2792 return fmt.Errorf("unsupported serialization of nil %T", v) 2793 } 2794 2795 if v.ThingName == nil || len(*v.ThingName) == 0 { 2796 return &smithy.SerializationError{Err: fmt.Errorf("input member ThingName must not be empty")} 2797 } 2798 if v.ThingName != nil { 2799 if err := encoder.SetURI("ThingName").String(*v.ThingName); err != nil { 2800 return err 2801 } 2802 } 2803 2804 return nil 2805} 2806 2807type awsRestjson1_serializeOpGetConnectorDefinition struct { 2808} 2809 2810func (*awsRestjson1_serializeOpGetConnectorDefinition) ID() string { 2811 return "OperationSerializer" 2812} 2813 2814func (m *awsRestjson1_serializeOpGetConnectorDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2815 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2816) { 2817 request, ok := in.Request.(*smithyhttp.Request) 2818 if !ok { 2819 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2820 } 2821 2822 input, ok := in.Parameters.(*GetConnectorDefinitionInput) 2823 _ = input 2824 if !ok { 2825 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2826 } 2827 2828 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}") 2829 request.URL.Path = opPath 2830 if len(request.URL.RawQuery) > 0 { 2831 request.URL.RawQuery = "&" + opQuery 2832 } else { 2833 request.URL.RawQuery = opQuery 2834 } 2835 2836 request.Method = "GET" 2837 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2838 if err != nil { 2839 return out, metadata, &smithy.SerializationError{Err: err} 2840 } 2841 2842 if err := awsRestjson1_serializeOpHttpBindingsGetConnectorDefinitionInput(input, restEncoder); err != nil { 2843 return out, metadata, &smithy.SerializationError{Err: err} 2844 } 2845 2846 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2847 return out, metadata, &smithy.SerializationError{Err: err} 2848 } 2849 in.Request = request 2850 2851 return next.HandleSerialize(ctx, in) 2852} 2853func awsRestjson1_serializeOpHttpBindingsGetConnectorDefinitionInput(v *GetConnectorDefinitionInput, encoder *httpbinding.Encoder) error { 2854 if v == nil { 2855 return fmt.Errorf("unsupported serialization of nil %T", v) 2856 } 2857 2858 if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 { 2859 return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")} 2860 } 2861 if v.ConnectorDefinitionId != nil { 2862 if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil { 2863 return err 2864 } 2865 } 2866 2867 return nil 2868} 2869 2870type awsRestjson1_serializeOpGetConnectorDefinitionVersion struct { 2871} 2872 2873func (*awsRestjson1_serializeOpGetConnectorDefinitionVersion) ID() string { 2874 return "OperationSerializer" 2875} 2876 2877func (m *awsRestjson1_serializeOpGetConnectorDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2878 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2879) { 2880 request, ok := in.Request.(*smithyhttp.Request) 2881 if !ok { 2882 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2883 } 2884 2885 input, ok := in.Parameters.(*GetConnectorDefinitionVersionInput) 2886 _ = input 2887 if !ok { 2888 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2889 } 2890 2891 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions/{ConnectorDefinitionVersionId}") 2892 request.URL.Path = opPath 2893 if len(request.URL.RawQuery) > 0 { 2894 request.URL.RawQuery = "&" + opQuery 2895 } else { 2896 request.URL.RawQuery = opQuery 2897 } 2898 2899 request.Method = "GET" 2900 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2901 if err != nil { 2902 return out, metadata, &smithy.SerializationError{Err: err} 2903 } 2904 2905 if err := awsRestjson1_serializeOpHttpBindingsGetConnectorDefinitionVersionInput(input, restEncoder); err != nil { 2906 return out, metadata, &smithy.SerializationError{Err: err} 2907 } 2908 2909 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2910 return out, metadata, &smithy.SerializationError{Err: err} 2911 } 2912 in.Request = request 2913 2914 return next.HandleSerialize(ctx, in) 2915} 2916func awsRestjson1_serializeOpHttpBindingsGetConnectorDefinitionVersionInput(v *GetConnectorDefinitionVersionInput, encoder *httpbinding.Encoder) error { 2917 if v == nil { 2918 return fmt.Errorf("unsupported serialization of nil %T", v) 2919 } 2920 2921 if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 { 2922 return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")} 2923 } 2924 if v.ConnectorDefinitionId != nil { 2925 if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil { 2926 return err 2927 } 2928 } 2929 2930 if v.ConnectorDefinitionVersionId == nil || len(*v.ConnectorDefinitionVersionId) == 0 { 2931 return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionVersionId must not be empty")} 2932 } 2933 if v.ConnectorDefinitionVersionId != nil { 2934 if err := encoder.SetURI("ConnectorDefinitionVersionId").String(*v.ConnectorDefinitionVersionId); err != nil { 2935 return err 2936 } 2937 } 2938 2939 if v.NextToken != nil { 2940 encoder.SetQuery("NextToken").String(*v.NextToken) 2941 } 2942 2943 return nil 2944} 2945 2946type awsRestjson1_serializeOpGetCoreDefinition struct { 2947} 2948 2949func (*awsRestjson1_serializeOpGetCoreDefinition) ID() string { 2950 return "OperationSerializer" 2951} 2952 2953func (m *awsRestjson1_serializeOpGetCoreDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2954 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2955) { 2956 request, ok := in.Request.(*smithyhttp.Request) 2957 if !ok { 2958 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2959 } 2960 2961 input, ok := in.Parameters.(*GetCoreDefinitionInput) 2962 _ = input 2963 if !ok { 2964 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2965 } 2966 2967 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}") 2968 request.URL.Path = opPath 2969 if len(request.URL.RawQuery) > 0 { 2970 request.URL.RawQuery = "&" + opQuery 2971 } else { 2972 request.URL.RawQuery = opQuery 2973 } 2974 2975 request.Method = "GET" 2976 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2977 if err != nil { 2978 return out, metadata, &smithy.SerializationError{Err: err} 2979 } 2980 2981 if err := awsRestjson1_serializeOpHttpBindingsGetCoreDefinitionInput(input, restEncoder); err != nil { 2982 return out, metadata, &smithy.SerializationError{Err: err} 2983 } 2984 2985 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2986 return out, metadata, &smithy.SerializationError{Err: err} 2987 } 2988 in.Request = request 2989 2990 return next.HandleSerialize(ctx, in) 2991} 2992func awsRestjson1_serializeOpHttpBindingsGetCoreDefinitionInput(v *GetCoreDefinitionInput, encoder *httpbinding.Encoder) error { 2993 if v == nil { 2994 return fmt.Errorf("unsupported serialization of nil %T", v) 2995 } 2996 2997 if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 { 2998 return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")} 2999 } 3000 if v.CoreDefinitionId != nil { 3001 if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil { 3002 return err 3003 } 3004 } 3005 3006 return nil 3007} 3008 3009type awsRestjson1_serializeOpGetCoreDefinitionVersion struct { 3010} 3011 3012func (*awsRestjson1_serializeOpGetCoreDefinitionVersion) ID() string { 3013 return "OperationSerializer" 3014} 3015 3016func (m *awsRestjson1_serializeOpGetCoreDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3017 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3018) { 3019 request, ok := in.Request.(*smithyhttp.Request) 3020 if !ok { 3021 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3022 } 3023 3024 input, ok := in.Parameters.(*GetCoreDefinitionVersionInput) 3025 _ = input 3026 if !ok { 3027 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3028 } 3029 3030 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}/versions/{CoreDefinitionVersionId}") 3031 request.URL.Path = opPath 3032 if len(request.URL.RawQuery) > 0 { 3033 request.URL.RawQuery = "&" + opQuery 3034 } else { 3035 request.URL.RawQuery = opQuery 3036 } 3037 3038 request.Method = "GET" 3039 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3040 if err != nil { 3041 return out, metadata, &smithy.SerializationError{Err: err} 3042 } 3043 3044 if err := awsRestjson1_serializeOpHttpBindingsGetCoreDefinitionVersionInput(input, restEncoder); err != nil { 3045 return out, metadata, &smithy.SerializationError{Err: err} 3046 } 3047 3048 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3049 return out, metadata, &smithy.SerializationError{Err: err} 3050 } 3051 in.Request = request 3052 3053 return next.HandleSerialize(ctx, in) 3054} 3055func awsRestjson1_serializeOpHttpBindingsGetCoreDefinitionVersionInput(v *GetCoreDefinitionVersionInput, encoder *httpbinding.Encoder) error { 3056 if v == nil { 3057 return fmt.Errorf("unsupported serialization of nil %T", v) 3058 } 3059 3060 if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 { 3061 return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")} 3062 } 3063 if v.CoreDefinitionId != nil { 3064 if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil { 3065 return err 3066 } 3067 } 3068 3069 if v.CoreDefinitionVersionId == nil || len(*v.CoreDefinitionVersionId) == 0 { 3070 return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionVersionId must not be empty")} 3071 } 3072 if v.CoreDefinitionVersionId != nil { 3073 if err := encoder.SetURI("CoreDefinitionVersionId").String(*v.CoreDefinitionVersionId); err != nil { 3074 return err 3075 } 3076 } 3077 3078 return nil 3079} 3080 3081type awsRestjson1_serializeOpGetDeploymentStatus struct { 3082} 3083 3084func (*awsRestjson1_serializeOpGetDeploymentStatus) ID() string { 3085 return "OperationSerializer" 3086} 3087 3088func (m *awsRestjson1_serializeOpGetDeploymentStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3089 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3090) { 3091 request, ok := in.Request.(*smithyhttp.Request) 3092 if !ok { 3093 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3094 } 3095 3096 input, ok := in.Parameters.(*GetDeploymentStatusInput) 3097 _ = input 3098 if !ok { 3099 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3100 } 3101 3102 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/deployments/{DeploymentId}/status") 3103 request.URL.Path = opPath 3104 if len(request.URL.RawQuery) > 0 { 3105 request.URL.RawQuery = "&" + opQuery 3106 } else { 3107 request.URL.RawQuery = opQuery 3108 } 3109 3110 request.Method = "GET" 3111 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3112 if err != nil { 3113 return out, metadata, &smithy.SerializationError{Err: err} 3114 } 3115 3116 if err := awsRestjson1_serializeOpHttpBindingsGetDeploymentStatusInput(input, restEncoder); err != nil { 3117 return out, metadata, &smithy.SerializationError{Err: err} 3118 } 3119 3120 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3121 return out, metadata, &smithy.SerializationError{Err: err} 3122 } 3123 in.Request = request 3124 3125 return next.HandleSerialize(ctx, in) 3126} 3127func awsRestjson1_serializeOpHttpBindingsGetDeploymentStatusInput(v *GetDeploymentStatusInput, encoder *httpbinding.Encoder) error { 3128 if v == nil { 3129 return fmt.Errorf("unsupported serialization of nil %T", v) 3130 } 3131 3132 if v.DeploymentId == nil || len(*v.DeploymentId) == 0 { 3133 return &smithy.SerializationError{Err: fmt.Errorf("input member DeploymentId must not be empty")} 3134 } 3135 if v.DeploymentId != nil { 3136 if err := encoder.SetURI("DeploymentId").String(*v.DeploymentId); err != nil { 3137 return err 3138 } 3139 } 3140 3141 if v.GroupId == nil || len(*v.GroupId) == 0 { 3142 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 3143 } 3144 if v.GroupId != nil { 3145 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 3146 return err 3147 } 3148 } 3149 3150 return nil 3151} 3152 3153type awsRestjson1_serializeOpGetDeviceDefinition struct { 3154} 3155 3156func (*awsRestjson1_serializeOpGetDeviceDefinition) ID() string { 3157 return "OperationSerializer" 3158} 3159 3160func (m *awsRestjson1_serializeOpGetDeviceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3161 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3162) { 3163 request, ok := in.Request.(*smithyhttp.Request) 3164 if !ok { 3165 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3166 } 3167 3168 input, ok := in.Parameters.(*GetDeviceDefinitionInput) 3169 _ = input 3170 if !ok { 3171 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3172 } 3173 3174 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}") 3175 request.URL.Path = opPath 3176 if len(request.URL.RawQuery) > 0 { 3177 request.URL.RawQuery = "&" + opQuery 3178 } else { 3179 request.URL.RawQuery = opQuery 3180 } 3181 3182 request.Method = "GET" 3183 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3184 if err != nil { 3185 return out, metadata, &smithy.SerializationError{Err: err} 3186 } 3187 3188 if err := awsRestjson1_serializeOpHttpBindingsGetDeviceDefinitionInput(input, restEncoder); err != nil { 3189 return out, metadata, &smithy.SerializationError{Err: err} 3190 } 3191 3192 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3193 return out, metadata, &smithy.SerializationError{Err: err} 3194 } 3195 in.Request = request 3196 3197 return next.HandleSerialize(ctx, in) 3198} 3199func awsRestjson1_serializeOpHttpBindingsGetDeviceDefinitionInput(v *GetDeviceDefinitionInput, encoder *httpbinding.Encoder) error { 3200 if v == nil { 3201 return fmt.Errorf("unsupported serialization of nil %T", v) 3202 } 3203 3204 if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 { 3205 return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")} 3206 } 3207 if v.DeviceDefinitionId != nil { 3208 if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil { 3209 return err 3210 } 3211 } 3212 3213 return nil 3214} 3215 3216type awsRestjson1_serializeOpGetDeviceDefinitionVersion struct { 3217} 3218 3219func (*awsRestjson1_serializeOpGetDeviceDefinitionVersion) ID() string { 3220 return "OperationSerializer" 3221} 3222 3223func (m *awsRestjson1_serializeOpGetDeviceDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3224 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3225) { 3226 request, ok := in.Request.(*smithyhttp.Request) 3227 if !ok { 3228 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3229 } 3230 3231 input, ok := in.Parameters.(*GetDeviceDefinitionVersionInput) 3232 _ = input 3233 if !ok { 3234 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3235 } 3236 3237 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}/versions/{DeviceDefinitionVersionId}") 3238 request.URL.Path = opPath 3239 if len(request.URL.RawQuery) > 0 { 3240 request.URL.RawQuery = "&" + opQuery 3241 } else { 3242 request.URL.RawQuery = opQuery 3243 } 3244 3245 request.Method = "GET" 3246 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3247 if err != nil { 3248 return out, metadata, &smithy.SerializationError{Err: err} 3249 } 3250 3251 if err := awsRestjson1_serializeOpHttpBindingsGetDeviceDefinitionVersionInput(input, restEncoder); err != nil { 3252 return out, metadata, &smithy.SerializationError{Err: err} 3253 } 3254 3255 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3256 return out, metadata, &smithy.SerializationError{Err: err} 3257 } 3258 in.Request = request 3259 3260 return next.HandleSerialize(ctx, in) 3261} 3262func awsRestjson1_serializeOpHttpBindingsGetDeviceDefinitionVersionInput(v *GetDeviceDefinitionVersionInput, encoder *httpbinding.Encoder) error { 3263 if v == nil { 3264 return fmt.Errorf("unsupported serialization of nil %T", v) 3265 } 3266 3267 if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 { 3268 return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")} 3269 } 3270 if v.DeviceDefinitionId != nil { 3271 if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil { 3272 return err 3273 } 3274 } 3275 3276 if v.DeviceDefinitionVersionId == nil || len(*v.DeviceDefinitionVersionId) == 0 { 3277 return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionVersionId must not be empty")} 3278 } 3279 if v.DeviceDefinitionVersionId != nil { 3280 if err := encoder.SetURI("DeviceDefinitionVersionId").String(*v.DeviceDefinitionVersionId); err != nil { 3281 return err 3282 } 3283 } 3284 3285 if v.NextToken != nil { 3286 encoder.SetQuery("NextToken").String(*v.NextToken) 3287 } 3288 3289 return nil 3290} 3291 3292type awsRestjson1_serializeOpGetFunctionDefinition struct { 3293} 3294 3295func (*awsRestjson1_serializeOpGetFunctionDefinition) ID() string { 3296 return "OperationSerializer" 3297} 3298 3299func (m *awsRestjson1_serializeOpGetFunctionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3300 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3301) { 3302 request, ok := in.Request.(*smithyhttp.Request) 3303 if !ok { 3304 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3305 } 3306 3307 input, ok := in.Parameters.(*GetFunctionDefinitionInput) 3308 _ = input 3309 if !ok { 3310 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3311 } 3312 3313 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}") 3314 request.URL.Path = opPath 3315 if len(request.URL.RawQuery) > 0 { 3316 request.URL.RawQuery = "&" + opQuery 3317 } else { 3318 request.URL.RawQuery = opQuery 3319 } 3320 3321 request.Method = "GET" 3322 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3323 if err != nil { 3324 return out, metadata, &smithy.SerializationError{Err: err} 3325 } 3326 3327 if err := awsRestjson1_serializeOpHttpBindingsGetFunctionDefinitionInput(input, restEncoder); err != nil { 3328 return out, metadata, &smithy.SerializationError{Err: err} 3329 } 3330 3331 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3332 return out, metadata, &smithy.SerializationError{Err: err} 3333 } 3334 in.Request = request 3335 3336 return next.HandleSerialize(ctx, in) 3337} 3338func awsRestjson1_serializeOpHttpBindingsGetFunctionDefinitionInput(v *GetFunctionDefinitionInput, encoder *httpbinding.Encoder) error { 3339 if v == nil { 3340 return fmt.Errorf("unsupported serialization of nil %T", v) 3341 } 3342 3343 if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 { 3344 return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")} 3345 } 3346 if v.FunctionDefinitionId != nil { 3347 if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil { 3348 return err 3349 } 3350 } 3351 3352 return nil 3353} 3354 3355type awsRestjson1_serializeOpGetFunctionDefinitionVersion struct { 3356} 3357 3358func (*awsRestjson1_serializeOpGetFunctionDefinitionVersion) ID() string { 3359 return "OperationSerializer" 3360} 3361 3362func (m *awsRestjson1_serializeOpGetFunctionDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3363 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3364) { 3365 request, ok := in.Request.(*smithyhttp.Request) 3366 if !ok { 3367 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3368 } 3369 3370 input, ok := in.Parameters.(*GetFunctionDefinitionVersionInput) 3371 _ = input 3372 if !ok { 3373 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3374 } 3375 3376 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}/versions/{FunctionDefinitionVersionId}") 3377 request.URL.Path = opPath 3378 if len(request.URL.RawQuery) > 0 { 3379 request.URL.RawQuery = "&" + opQuery 3380 } else { 3381 request.URL.RawQuery = opQuery 3382 } 3383 3384 request.Method = "GET" 3385 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3386 if err != nil { 3387 return out, metadata, &smithy.SerializationError{Err: err} 3388 } 3389 3390 if err := awsRestjson1_serializeOpHttpBindingsGetFunctionDefinitionVersionInput(input, restEncoder); err != nil { 3391 return out, metadata, &smithy.SerializationError{Err: err} 3392 } 3393 3394 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3395 return out, metadata, &smithy.SerializationError{Err: err} 3396 } 3397 in.Request = request 3398 3399 return next.HandleSerialize(ctx, in) 3400} 3401func awsRestjson1_serializeOpHttpBindingsGetFunctionDefinitionVersionInput(v *GetFunctionDefinitionVersionInput, encoder *httpbinding.Encoder) error { 3402 if v == nil { 3403 return fmt.Errorf("unsupported serialization of nil %T", v) 3404 } 3405 3406 if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 { 3407 return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")} 3408 } 3409 if v.FunctionDefinitionId != nil { 3410 if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil { 3411 return err 3412 } 3413 } 3414 3415 if v.FunctionDefinitionVersionId == nil || len(*v.FunctionDefinitionVersionId) == 0 { 3416 return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionVersionId must not be empty")} 3417 } 3418 if v.FunctionDefinitionVersionId != nil { 3419 if err := encoder.SetURI("FunctionDefinitionVersionId").String(*v.FunctionDefinitionVersionId); err != nil { 3420 return err 3421 } 3422 } 3423 3424 if v.NextToken != nil { 3425 encoder.SetQuery("NextToken").String(*v.NextToken) 3426 } 3427 3428 return nil 3429} 3430 3431type awsRestjson1_serializeOpGetGroup struct { 3432} 3433 3434func (*awsRestjson1_serializeOpGetGroup) ID() string { 3435 return "OperationSerializer" 3436} 3437 3438func (m *awsRestjson1_serializeOpGetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3439 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3440) { 3441 request, ok := in.Request.(*smithyhttp.Request) 3442 if !ok { 3443 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3444 } 3445 3446 input, ok := in.Parameters.(*GetGroupInput) 3447 _ = input 3448 if !ok { 3449 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3450 } 3451 3452 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}") 3453 request.URL.Path = opPath 3454 if len(request.URL.RawQuery) > 0 { 3455 request.URL.RawQuery = "&" + opQuery 3456 } else { 3457 request.URL.RawQuery = opQuery 3458 } 3459 3460 request.Method = "GET" 3461 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3462 if err != nil { 3463 return out, metadata, &smithy.SerializationError{Err: err} 3464 } 3465 3466 if err := awsRestjson1_serializeOpHttpBindingsGetGroupInput(input, restEncoder); err != nil { 3467 return out, metadata, &smithy.SerializationError{Err: err} 3468 } 3469 3470 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3471 return out, metadata, &smithy.SerializationError{Err: err} 3472 } 3473 in.Request = request 3474 3475 return next.HandleSerialize(ctx, in) 3476} 3477func awsRestjson1_serializeOpHttpBindingsGetGroupInput(v *GetGroupInput, encoder *httpbinding.Encoder) error { 3478 if v == nil { 3479 return fmt.Errorf("unsupported serialization of nil %T", v) 3480 } 3481 3482 if v.GroupId == nil || len(*v.GroupId) == 0 { 3483 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 3484 } 3485 if v.GroupId != nil { 3486 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 3487 return err 3488 } 3489 } 3490 3491 return nil 3492} 3493 3494type awsRestjson1_serializeOpGetGroupCertificateAuthority struct { 3495} 3496 3497func (*awsRestjson1_serializeOpGetGroupCertificateAuthority) ID() string { 3498 return "OperationSerializer" 3499} 3500 3501func (m *awsRestjson1_serializeOpGetGroupCertificateAuthority) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3502 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3503) { 3504 request, ok := in.Request.(*smithyhttp.Request) 3505 if !ok { 3506 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3507 } 3508 3509 input, ok := in.Parameters.(*GetGroupCertificateAuthorityInput) 3510 _ = input 3511 if !ok { 3512 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3513 } 3514 3515 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities/{CertificateAuthorityId}") 3516 request.URL.Path = opPath 3517 if len(request.URL.RawQuery) > 0 { 3518 request.URL.RawQuery = "&" + opQuery 3519 } else { 3520 request.URL.RawQuery = opQuery 3521 } 3522 3523 request.Method = "GET" 3524 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3525 if err != nil { 3526 return out, metadata, &smithy.SerializationError{Err: err} 3527 } 3528 3529 if err := awsRestjson1_serializeOpHttpBindingsGetGroupCertificateAuthorityInput(input, restEncoder); err != nil { 3530 return out, metadata, &smithy.SerializationError{Err: err} 3531 } 3532 3533 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3534 return out, metadata, &smithy.SerializationError{Err: err} 3535 } 3536 in.Request = request 3537 3538 return next.HandleSerialize(ctx, in) 3539} 3540func awsRestjson1_serializeOpHttpBindingsGetGroupCertificateAuthorityInput(v *GetGroupCertificateAuthorityInput, encoder *httpbinding.Encoder) error { 3541 if v == nil { 3542 return fmt.Errorf("unsupported serialization of nil %T", v) 3543 } 3544 3545 if v.CertificateAuthorityId == nil || len(*v.CertificateAuthorityId) == 0 { 3546 return &smithy.SerializationError{Err: fmt.Errorf("input member CertificateAuthorityId must not be empty")} 3547 } 3548 if v.CertificateAuthorityId != nil { 3549 if err := encoder.SetURI("CertificateAuthorityId").String(*v.CertificateAuthorityId); err != nil { 3550 return err 3551 } 3552 } 3553 3554 if v.GroupId == nil || len(*v.GroupId) == 0 { 3555 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 3556 } 3557 if v.GroupId != nil { 3558 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 3559 return err 3560 } 3561 } 3562 3563 return nil 3564} 3565 3566type awsRestjson1_serializeOpGetGroupCertificateConfiguration struct { 3567} 3568 3569func (*awsRestjson1_serializeOpGetGroupCertificateConfiguration) ID() string { 3570 return "OperationSerializer" 3571} 3572 3573func (m *awsRestjson1_serializeOpGetGroupCertificateConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3574 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3575) { 3576 request, ok := in.Request.(*smithyhttp.Request) 3577 if !ok { 3578 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3579 } 3580 3581 input, ok := in.Parameters.(*GetGroupCertificateConfigurationInput) 3582 _ = input 3583 if !ok { 3584 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3585 } 3586 3587 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry") 3588 request.URL.Path = opPath 3589 if len(request.URL.RawQuery) > 0 { 3590 request.URL.RawQuery = "&" + opQuery 3591 } else { 3592 request.URL.RawQuery = opQuery 3593 } 3594 3595 request.Method = "GET" 3596 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3597 if err != nil { 3598 return out, metadata, &smithy.SerializationError{Err: err} 3599 } 3600 3601 if err := awsRestjson1_serializeOpHttpBindingsGetGroupCertificateConfigurationInput(input, restEncoder); err != nil { 3602 return out, metadata, &smithy.SerializationError{Err: err} 3603 } 3604 3605 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3606 return out, metadata, &smithy.SerializationError{Err: err} 3607 } 3608 in.Request = request 3609 3610 return next.HandleSerialize(ctx, in) 3611} 3612func awsRestjson1_serializeOpHttpBindingsGetGroupCertificateConfigurationInput(v *GetGroupCertificateConfigurationInput, encoder *httpbinding.Encoder) error { 3613 if v == nil { 3614 return fmt.Errorf("unsupported serialization of nil %T", v) 3615 } 3616 3617 if v.GroupId == nil || len(*v.GroupId) == 0 { 3618 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 3619 } 3620 if v.GroupId != nil { 3621 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 3622 return err 3623 } 3624 } 3625 3626 return nil 3627} 3628 3629type awsRestjson1_serializeOpGetGroupVersion struct { 3630} 3631 3632func (*awsRestjson1_serializeOpGetGroupVersion) ID() string { 3633 return "OperationSerializer" 3634} 3635 3636func (m *awsRestjson1_serializeOpGetGroupVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3637 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3638) { 3639 request, ok := in.Request.(*smithyhttp.Request) 3640 if !ok { 3641 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3642 } 3643 3644 input, ok := in.Parameters.(*GetGroupVersionInput) 3645 _ = input 3646 if !ok { 3647 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3648 } 3649 3650 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/versions/{GroupVersionId}") 3651 request.URL.Path = opPath 3652 if len(request.URL.RawQuery) > 0 { 3653 request.URL.RawQuery = "&" + opQuery 3654 } else { 3655 request.URL.RawQuery = opQuery 3656 } 3657 3658 request.Method = "GET" 3659 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3660 if err != nil { 3661 return out, metadata, &smithy.SerializationError{Err: err} 3662 } 3663 3664 if err := awsRestjson1_serializeOpHttpBindingsGetGroupVersionInput(input, restEncoder); err != nil { 3665 return out, metadata, &smithy.SerializationError{Err: err} 3666 } 3667 3668 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3669 return out, metadata, &smithy.SerializationError{Err: err} 3670 } 3671 in.Request = request 3672 3673 return next.HandleSerialize(ctx, in) 3674} 3675func awsRestjson1_serializeOpHttpBindingsGetGroupVersionInput(v *GetGroupVersionInput, encoder *httpbinding.Encoder) error { 3676 if v == nil { 3677 return fmt.Errorf("unsupported serialization of nil %T", v) 3678 } 3679 3680 if v.GroupId == nil || len(*v.GroupId) == 0 { 3681 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 3682 } 3683 if v.GroupId != nil { 3684 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 3685 return err 3686 } 3687 } 3688 3689 if v.GroupVersionId == nil || len(*v.GroupVersionId) == 0 { 3690 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupVersionId must not be empty")} 3691 } 3692 if v.GroupVersionId != nil { 3693 if err := encoder.SetURI("GroupVersionId").String(*v.GroupVersionId); err != nil { 3694 return err 3695 } 3696 } 3697 3698 return nil 3699} 3700 3701type awsRestjson1_serializeOpGetLoggerDefinition struct { 3702} 3703 3704func (*awsRestjson1_serializeOpGetLoggerDefinition) ID() string { 3705 return "OperationSerializer" 3706} 3707 3708func (m *awsRestjson1_serializeOpGetLoggerDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3709 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3710) { 3711 request, ok := in.Request.(*smithyhttp.Request) 3712 if !ok { 3713 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3714 } 3715 3716 input, ok := in.Parameters.(*GetLoggerDefinitionInput) 3717 _ = input 3718 if !ok { 3719 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3720 } 3721 3722 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}") 3723 request.URL.Path = opPath 3724 if len(request.URL.RawQuery) > 0 { 3725 request.URL.RawQuery = "&" + opQuery 3726 } else { 3727 request.URL.RawQuery = opQuery 3728 } 3729 3730 request.Method = "GET" 3731 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3732 if err != nil { 3733 return out, metadata, &smithy.SerializationError{Err: err} 3734 } 3735 3736 if err := awsRestjson1_serializeOpHttpBindingsGetLoggerDefinitionInput(input, restEncoder); err != nil { 3737 return out, metadata, &smithy.SerializationError{Err: err} 3738 } 3739 3740 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3741 return out, metadata, &smithy.SerializationError{Err: err} 3742 } 3743 in.Request = request 3744 3745 return next.HandleSerialize(ctx, in) 3746} 3747func awsRestjson1_serializeOpHttpBindingsGetLoggerDefinitionInput(v *GetLoggerDefinitionInput, encoder *httpbinding.Encoder) error { 3748 if v == nil { 3749 return fmt.Errorf("unsupported serialization of nil %T", v) 3750 } 3751 3752 if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 { 3753 return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")} 3754 } 3755 if v.LoggerDefinitionId != nil { 3756 if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil { 3757 return err 3758 } 3759 } 3760 3761 return nil 3762} 3763 3764type awsRestjson1_serializeOpGetLoggerDefinitionVersion struct { 3765} 3766 3767func (*awsRestjson1_serializeOpGetLoggerDefinitionVersion) ID() string { 3768 return "OperationSerializer" 3769} 3770 3771func (m *awsRestjson1_serializeOpGetLoggerDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3772 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3773) { 3774 request, ok := in.Request.(*smithyhttp.Request) 3775 if !ok { 3776 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3777 } 3778 3779 input, ok := in.Parameters.(*GetLoggerDefinitionVersionInput) 3780 _ = input 3781 if !ok { 3782 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3783 } 3784 3785 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}/versions/{LoggerDefinitionVersionId}") 3786 request.URL.Path = opPath 3787 if len(request.URL.RawQuery) > 0 { 3788 request.URL.RawQuery = "&" + opQuery 3789 } else { 3790 request.URL.RawQuery = opQuery 3791 } 3792 3793 request.Method = "GET" 3794 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3795 if err != nil { 3796 return out, metadata, &smithy.SerializationError{Err: err} 3797 } 3798 3799 if err := awsRestjson1_serializeOpHttpBindingsGetLoggerDefinitionVersionInput(input, restEncoder); err != nil { 3800 return out, metadata, &smithy.SerializationError{Err: err} 3801 } 3802 3803 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3804 return out, metadata, &smithy.SerializationError{Err: err} 3805 } 3806 in.Request = request 3807 3808 return next.HandleSerialize(ctx, in) 3809} 3810func awsRestjson1_serializeOpHttpBindingsGetLoggerDefinitionVersionInput(v *GetLoggerDefinitionVersionInput, encoder *httpbinding.Encoder) error { 3811 if v == nil { 3812 return fmt.Errorf("unsupported serialization of nil %T", v) 3813 } 3814 3815 if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 { 3816 return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")} 3817 } 3818 if v.LoggerDefinitionId != nil { 3819 if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil { 3820 return err 3821 } 3822 } 3823 3824 if v.LoggerDefinitionVersionId == nil || len(*v.LoggerDefinitionVersionId) == 0 { 3825 return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionVersionId must not be empty")} 3826 } 3827 if v.LoggerDefinitionVersionId != nil { 3828 if err := encoder.SetURI("LoggerDefinitionVersionId").String(*v.LoggerDefinitionVersionId); err != nil { 3829 return err 3830 } 3831 } 3832 3833 if v.NextToken != nil { 3834 encoder.SetQuery("NextToken").String(*v.NextToken) 3835 } 3836 3837 return nil 3838} 3839 3840type awsRestjson1_serializeOpGetResourceDefinition struct { 3841} 3842 3843func (*awsRestjson1_serializeOpGetResourceDefinition) ID() string { 3844 return "OperationSerializer" 3845} 3846 3847func (m *awsRestjson1_serializeOpGetResourceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3848 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3849) { 3850 request, ok := in.Request.(*smithyhttp.Request) 3851 if !ok { 3852 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3853 } 3854 3855 input, ok := in.Parameters.(*GetResourceDefinitionInput) 3856 _ = input 3857 if !ok { 3858 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3859 } 3860 3861 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}") 3862 request.URL.Path = opPath 3863 if len(request.URL.RawQuery) > 0 { 3864 request.URL.RawQuery = "&" + opQuery 3865 } else { 3866 request.URL.RawQuery = opQuery 3867 } 3868 3869 request.Method = "GET" 3870 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3871 if err != nil { 3872 return out, metadata, &smithy.SerializationError{Err: err} 3873 } 3874 3875 if err := awsRestjson1_serializeOpHttpBindingsGetResourceDefinitionInput(input, restEncoder); err != nil { 3876 return out, metadata, &smithy.SerializationError{Err: err} 3877 } 3878 3879 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3880 return out, metadata, &smithy.SerializationError{Err: err} 3881 } 3882 in.Request = request 3883 3884 return next.HandleSerialize(ctx, in) 3885} 3886func awsRestjson1_serializeOpHttpBindingsGetResourceDefinitionInput(v *GetResourceDefinitionInput, encoder *httpbinding.Encoder) error { 3887 if v == nil { 3888 return fmt.Errorf("unsupported serialization of nil %T", v) 3889 } 3890 3891 if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 { 3892 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")} 3893 } 3894 if v.ResourceDefinitionId != nil { 3895 if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil { 3896 return err 3897 } 3898 } 3899 3900 return nil 3901} 3902 3903type awsRestjson1_serializeOpGetResourceDefinitionVersion struct { 3904} 3905 3906func (*awsRestjson1_serializeOpGetResourceDefinitionVersion) ID() string { 3907 return "OperationSerializer" 3908} 3909 3910func (m *awsRestjson1_serializeOpGetResourceDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3911 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3912) { 3913 request, ok := in.Request.(*smithyhttp.Request) 3914 if !ok { 3915 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3916 } 3917 3918 input, ok := in.Parameters.(*GetResourceDefinitionVersionInput) 3919 _ = input 3920 if !ok { 3921 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3922 } 3923 3924 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}/versions/{ResourceDefinitionVersionId}") 3925 request.URL.Path = opPath 3926 if len(request.URL.RawQuery) > 0 { 3927 request.URL.RawQuery = "&" + opQuery 3928 } else { 3929 request.URL.RawQuery = opQuery 3930 } 3931 3932 request.Method = "GET" 3933 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3934 if err != nil { 3935 return out, metadata, &smithy.SerializationError{Err: err} 3936 } 3937 3938 if err := awsRestjson1_serializeOpHttpBindingsGetResourceDefinitionVersionInput(input, restEncoder); err != nil { 3939 return out, metadata, &smithy.SerializationError{Err: err} 3940 } 3941 3942 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3943 return out, metadata, &smithy.SerializationError{Err: err} 3944 } 3945 in.Request = request 3946 3947 return next.HandleSerialize(ctx, in) 3948} 3949func awsRestjson1_serializeOpHttpBindingsGetResourceDefinitionVersionInput(v *GetResourceDefinitionVersionInput, encoder *httpbinding.Encoder) error { 3950 if v == nil { 3951 return fmt.Errorf("unsupported serialization of nil %T", v) 3952 } 3953 3954 if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 { 3955 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")} 3956 } 3957 if v.ResourceDefinitionId != nil { 3958 if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil { 3959 return err 3960 } 3961 } 3962 3963 if v.ResourceDefinitionVersionId == nil || len(*v.ResourceDefinitionVersionId) == 0 { 3964 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionVersionId must not be empty")} 3965 } 3966 if v.ResourceDefinitionVersionId != nil { 3967 if err := encoder.SetURI("ResourceDefinitionVersionId").String(*v.ResourceDefinitionVersionId); err != nil { 3968 return err 3969 } 3970 } 3971 3972 return nil 3973} 3974 3975type awsRestjson1_serializeOpGetServiceRoleForAccount struct { 3976} 3977 3978func (*awsRestjson1_serializeOpGetServiceRoleForAccount) ID() string { 3979 return "OperationSerializer" 3980} 3981 3982func (m *awsRestjson1_serializeOpGetServiceRoleForAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3983 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3984) { 3985 request, ok := in.Request.(*smithyhttp.Request) 3986 if !ok { 3987 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3988 } 3989 3990 input, ok := in.Parameters.(*GetServiceRoleForAccountInput) 3991 _ = input 3992 if !ok { 3993 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3994 } 3995 3996 opPath, opQuery := httpbinding.SplitURI("/greengrass/servicerole") 3997 request.URL.Path = opPath 3998 if len(request.URL.RawQuery) > 0 { 3999 request.URL.RawQuery = "&" + opQuery 4000 } else { 4001 request.URL.RawQuery = opQuery 4002 } 4003 4004 request.Method = "GET" 4005 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4006 if err != nil { 4007 return out, metadata, &smithy.SerializationError{Err: err} 4008 } 4009 4010 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4011 return out, metadata, &smithy.SerializationError{Err: err} 4012 } 4013 in.Request = request 4014 4015 return next.HandleSerialize(ctx, in) 4016} 4017func awsRestjson1_serializeOpHttpBindingsGetServiceRoleForAccountInput(v *GetServiceRoleForAccountInput, encoder *httpbinding.Encoder) error { 4018 if v == nil { 4019 return fmt.Errorf("unsupported serialization of nil %T", v) 4020 } 4021 4022 return nil 4023} 4024 4025type awsRestjson1_serializeOpGetSubscriptionDefinition struct { 4026} 4027 4028func (*awsRestjson1_serializeOpGetSubscriptionDefinition) ID() string { 4029 return "OperationSerializer" 4030} 4031 4032func (m *awsRestjson1_serializeOpGetSubscriptionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4033 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4034) { 4035 request, ok := in.Request.(*smithyhttp.Request) 4036 if !ok { 4037 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4038 } 4039 4040 input, ok := in.Parameters.(*GetSubscriptionDefinitionInput) 4041 _ = input 4042 if !ok { 4043 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4044 } 4045 4046 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}") 4047 request.URL.Path = opPath 4048 if len(request.URL.RawQuery) > 0 { 4049 request.URL.RawQuery = "&" + opQuery 4050 } else { 4051 request.URL.RawQuery = opQuery 4052 } 4053 4054 request.Method = "GET" 4055 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4056 if err != nil { 4057 return out, metadata, &smithy.SerializationError{Err: err} 4058 } 4059 4060 if err := awsRestjson1_serializeOpHttpBindingsGetSubscriptionDefinitionInput(input, restEncoder); err != nil { 4061 return out, metadata, &smithy.SerializationError{Err: err} 4062 } 4063 4064 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4065 return out, metadata, &smithy.SerializationError{Err: err} 4066 } 4067 in.Request = request 4068 4069 return next.HandleSerialize(ctx, in) 4070} 4071func awsRestjson1_serializeOpHttpBindingsGetSubscriptionDefinitionInput(v *GetSubscriptionDefinitionInput, encoder *httpbinding.Encoder) error { 4072 if v == nil { 4073 return fmt.Errorf("unsupported serialization of nil %T", v) 4074 } 4075 4076 if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 { 4077 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")} 4078 } 4079 if v.SubscriptionDefinitionId != nil { 4080 if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil { 4081 return err 4082 } 4083 } 4084 4085 return nil 4086} 4087 4088type awsRestjson1_serializeOpGetSubscriptionDefinitionVersion struct { 4089} 4090 4091func (*awsRestjson1_serializeOpGetSubscriptionDefinitionVersion) ID() string { 4092 return "OperationSerializer" 4093} 4094 4095func (m *awsRestjson1_serializeOpGetSubscriptionDefinitionVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4096 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4097) { 4098 request, ok := in.Request.(*smithyhttp.Request) 4099 if !ok { 4100 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4101 } 4102 4103 input, ok := in.Parameters.(*GetSubscriptionDefinitionVersionInput) 4104 _ = input 4105 if !ok { 4106 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4107 } 4108 4109 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions/{SubscriptionDefinitionVersionId}") 4110 request.URL.Path = opPath 4111 if len(request.URL.RawQuery) > 0 { 4112 request.URL.RawQuery = "&" + opQuery 4113 } else { 4114 request.URL.RawQuery = opQuery 4115 } 4116 4117 request.Method = "GET" 4118 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4119 if err != nil { 4120 return out, metadata, &smithy.SerializationError{Err: err} 4121 } 4122 4123 if err := awsRestjson1_serializeOpHttpBindingsGetSubscriptionDefinitionVersionInput(input, restEncoder); err != nil { 4124 return out, metadata, &smithy.SerializationError{Err: err} 4125 } 4126 4127 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4128 return out, metadata, &smithy.SerializationError{Err: err} 4129 } 4130 in.Request = request 4131 4132 return next.HandleSerialize(ctx, in) 4133} 4134func awsRestjson1_serializeOpHttpBindingsGetSubscriptionDefinitionVersionInput(v *GetSubscriptionDefinitionVersionInput, encoder *httpbinding.Encoder) error { 4135 if v == nil { 4136 return fmt.Errorf("unsupported serialization of nil %T", v) 4137 } 4138 4139 if v.NextToken != nil { 4140 encoder.SetQuery("NextToken").String(*v.NextToken) 4141 } 4142 4143 if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 { 4144 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")} 4145 } 4146 if v.SubscriptionDefinitionId != nil { 4147 if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil { 4148 return err 4149 } 4150 } 4151 4152 if v.SubscriptionDefinitionVersionId == nil || len(*v.SubscriptionDefinitionVersionId) == 0 { 4153 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionVersionId must not be empty")} 4154 } 4155 if v.SubscriptionDefinitionVersionId != nil { 4156 if err := encoder.SetURI("SubscriptionDefinitionVersionId").String(*v.SubscriptionDefinitionVersionId); err != nil { 4157 return err 4158 } 4159 } 4160 4161 return nil 4162} 4163 4164type awsRestjson1_serializeOpGetThingRuntimeConfiguration struct { 4165} 4166 4167func (*awsRestjson1_serializeOpGetThingRuntimeConfiguration) ID() string { 4168 return "OperationSerializer" 4169} 4170 4171func (m *awsRestjson1_serializeOpGetThingRuntimeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4172 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4173) { 4174 request, ok := in.Request.(*smithyhttp.Request) 4175 if !ok { 4176 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4177 } 4178 4179 input, ok := in.Parameters.(*GetThingRuntimeConfigurationInput) 4180 _ = input 4181 if !ok { 4182 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4183 } 4184 4185 opPath, opQuery := httpbinding.SplitURI("/greengrass/things/{ThingName}/runtimeconfig") 4186 request.URL.Path = opPath 4187 if len(request.URL.RawQuery) > 0 { 4188 request.URL.RawQuery = "&" + opQuery 4189 } else { 4190 request.URL.RawQuery = opQuery 4191 } 4192 4193 request.Method = "GET" 4194 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4195 if err != nil { 4196 return out, metadata, &smithy.SerializationError{Err: err} 4197 } 4198 4199 if err := awsRestjson1_serializeOpHttpBindingsGetThingRuntimeConfigurationInput(input, restEncoder); err != nil { 4200 return out, metadata, &smithy.SerializationError{Err: err} 4201 } 4202 4203 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4204 return out, metadata, &smithy.SerializationError{Err: err} 4205 } 4206 in.Request = request 4207 4208 return next.HandleSerialize(ctx, in) 4209} 4210func awsRestjson1_serializeOpHttpBindingsGetThingRuntimeConfigurationInput(v *GetThingRuntimeConfigurationInput, encoder *httpbinding.Encoder) error { 4211 if v == nil { 4212 return fmt.Errorf("unsupported serialization of nil %T", v) 4213 } 4214 4215 if v.ThingName == nil || len(*v.ThingName) == 0 { 4216 return &smithy.SerializationError{Err: fmt.Errorf("input member ThingName must not be empty")} 4217 } 4218 if v.ThingName != nil { 4219 if err := encoder.SetURI("ThingName").String(*v.ThingName); err != nil { 4220 return err 4221 } 4222 } 4223 4224 return nil 4225} 4226 4227type awsRestjson1_serializeOpListBulkDeploymentDetailedReports struct { 4228} 4229 4230func (*awsRestjson1_serializeOpListBulkDeploymentDetailedReports) ID() string { 4231 return "OperationSerializer" 4232} 4233 4234func (m *awsRestjson1_serializeOpListBulkDeploymentDetailedReports) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4235 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4236) { 4237 request, ok := in.Request.(*smithyhttp.Request) 4238 if !ok { 4239 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4240 } 4241 4242 input, ok := in.Parameters.(*ListBulkDeploymentDetailedReportsInput) 4243 _ = input 4244 if !ok { 4245 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4246 } 4247 4248 opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments/{BulkDeploymentId}/detailed-reports") 4249 request.URL.Path = opPath 4250 if len(request.URL.RawQuery) > 0 { 4251 request.URL.RawQuery = "&" + opQuery 4252 } else { 4253 request.URL.RawQuery = opQuery 4254 } 4255 4256 request.Method = "GET" 4257 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4258 if err != nil { 4259 return out, metadata, &smithy.SerializationError{Err: err} 4260 } 4261 4262 if err := awsRestjson1_serializeOpHttpBindingsListBulkDeploymentDetailedReportsInput(input, restEncoder); err != nil { 4263 return out, metadata, &smithy.SerializationError{Err: err} 4264 } 4265 4266 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4267 return out, metadata, &smithy.SerializationError{Err: err} 4268 } 4269 in.Request = request 4270 4271 return next.HandleSerialize(ctx, in) 4272} 4273func awsRestjson1_serializeOpHttpBindingsListBulkDeploymentDetailedReportsInput(v *ListBulkDeploymentDetailedReportsInput, encoder *httpbinding.Encoder) error { 4274 if v == nil { 4275 return fmt.Errorf("unsupported serialization of nil %T", v) 4276 } 4277 4278 if v.BulkDeploymentId == nil || len(*v.BulkDeploymentId) == 0 { 4279 return &smithy.SerializationError{Err: fmt.Errorf("input member BulkDeploymentId must not be empty")} 4280 } 4281 if v.BulkDeploymentId != nil { 4282 if err := encoder.SetURI("BulkDeploymentId").String(*v.BulkDeploymentId); err != nil { 4283 return err 4284 } 4285 } 4286 4287 if v.MaxResults != nil { 4288 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4289 } 4290 4291 if v.NextToken != nil { 4292 encoder.SetQuery("NextToken").String(*v.NextToken) 4293 } 4294 4295 return nil 4296} 4297 4298type awsRestjson1_serializeOpListBulkDeployments struct { 4299} 4300 4301func (*awsRestjson1_serializeOpListBulkDeployments) ID() string { 4302 return "OperationSerializer" 4303} 4304 4305func (m *awsRestjson1_serializeOpListBulkDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4306 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4307) { 4308 request, ok := in.Request.(*smithyhttp.Request) 4309 if !ok { 4310 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4311 } 4312 4313 input, ok := in.Parameters.(*ListBulkDeploymentsInput) 4314 _ = input 4315 if !ok { 4316 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4317 } 4318 4319 opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments") 4320 request.URL.Path = opPath 4321 if len(request.URL.RawQuery) > 0 { 4322 request.URL.RawQuery = "&" + opQuery 4323 } else { 4324 request.URL.RawQuery = opQuery 4325 } 4326 4327 request.Method = "GET" 4328 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4329 if err != nil { 4330 return out, metadata, &smithy.SerializationError{Err: err} 4331 } 4332 4333 if err := awsRestjson1_serializeOpHttpBindingsListBulkDeploymentsInput(input, restEncoder); err != nil { 4334 return out, metadata, &smithy.SerializationError{Err: err} 4335 } 4336 4337 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4338 return out, metadata, &smithy.SerializationError{Err: err} 4339 } 4340 in.Request = request 4341 4342 return next.HandleSerialize(ctx, in) 4343} 4344func awsRestjson1_serializeOpHttpBindingsListBulkDeploymentsInput(v *ListBulkDeploymentsInput, encoder *httpbinding.Encoder) error { 4345 if v == nil { 4346 return fmt.Errorf("unsupported serialization of nil %T", v) 4347 } 4348 4349 if v.MaxResults != nil { 4350 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4351 } 4352 4353 if v.NextToken != nil { 4354 encoder.SetQuery("NextToken").String(*v.NextToken) 4355 } 4356 4357 return nil 4358} 4359 4360type awsRestjson1_serializeOpListConnectorDefinitions struct { 4361} 4362 4363func (*awsRestjson1_serializeOpListConnectorDefinitions) ID() string { 4364 return "OperationSerializer" 4365} 4366 4367func (m *awsRestjson1_serializeOpListConnectorDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4368 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4369) { 4370 request, ok := in.Request.(*smithyhttp.Request) 4371 if !ok { 4372 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4373 } 4374 4375 input, ok := in.Parameters.(*ListConnectorDefinitionsInput) 4376 _ = input 4377 if !ok { 4378 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4379 } 4380 4381 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors") 4382 request.URL.Path = opPath 4383 if len(request.URL.RawQuery) > 0 { 4384 request.URL.RawQuery = "&" + opQuery 4385 } else { 4386 request.URL.RawQuery = opQuery 4387 } 4388 4389 request.Method = "GET" 4390 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4391 if err != nil { 4392 return out, metadata, &smithy.SerializationError{Err: err} 4393 } 4394 4395 if err := awsRestjson1_serializeOpHttpBindingsListConnectorDefinitionsInput(input, restEncoder); err != nil { 4396 return out, metadata, &smithy.SerializationError{Err: err} 4397 } 4398 4399 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4400 return out, metadata, &smithy.SerializationError{Err: err} 4401 } 4402 in.Request = request 4403 4404 return next.HandleSerialize(ctx, in) 4405} 4406func awsRestjson1_serializeOpHttpBindingsListConnectorDefinitionsInput(v *ListConnectorDefinitionsInput, encoder *httpbinding.Encoder) error { 4407 if v == nil { 4408 return fmt.Errorf("unsupported serialization of nil %T", v) 4409 } 4410 4411 if v.MaxResults != nil { 4412 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4413 } 4414 4415 if v.NextToken != nil { 4416 encoder.SetQuery("NextToken").String(*v.NextToken) 4417 } 4418 4419 return nil 4420} 4421 4422type awsRestjson1_serializeOpListConnectorDefinitionVersions struct { 4423} 4424 4425func (*awsRestjson1_serializeOpListConnectorDefinitionVersions) ID() string { 4426 return "OperationSerializer" 4427} 4428 4429func (m *awsRestjson1_serializeOpListConnectorDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4430 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4431) { 4432 request, ok := in.Request.(*smithyhttp.Request) 4433 if !ok { 4434 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4435 } 4436 4437 input, ok := in.Parameters.(*ListConnectorDefinitionVersionsInput) 4438 _ = input 4439 if !ok { 4440 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4441 } 4442 4443 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}/versions") 4444 request.URL.Path = opPath 4445 if len(request.URL.RawQuery) > 0 { 4446 request.URL.RawQuery = "&" + opQuery 4447 } else { 4448 request.URL.RawQuery = opQuery 4449 } 4450 4451 request.Method = "GET" 4452 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4453 if err != nil { 4454 return out, metadata, &smithy.SerializationError{Err: err} 4455 } 4456 4457 if err := awsRestjson1_serializeOpHttpBindingsListConnectorDefinitionVersionsInput(input, restEncoder); err != nil { 4458 return out, metadata, &smithy.SerializationError{Err: err} 4459 } 4460 4461 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4462 return out, metadata, &smithy.SerializationError{Err: err} 4463 } 4464 in.Request = request 4465 4466 return next.HandleSerialize(ctx, in) 4467} 4468func awsRestjson1_serializeOpHttpBindingsListConnectorDefinitionVersionsInput(v *ListConnectorDefinitionVersionsInput, encoder *httpbinding.Encoder) error { 4469 if v == nil { 4470 return fmt.Errorf("unsupported serialization of nil %T", v) 4471 } 4472 4473 if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 { 4474 return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")} 4475 } 4476 if v.ConnectorDefinitionId != nil { 4477 if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil { 4478 return err 4479 } 4480 } 4481 4482 if v.MaxResults != nil { 4483 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4484 } 4485 4486 if v.NextToken != nil { 4487 encoder.SetQuery("NextToken").String(*v.NextToken) 4488 } 4489 4490 return nil 4491} 4492 4493type awsRestjson1_serializeOpListCoreDefinitions struct { 4494} 4495 4496func (*awsRestjson1_serializeOpListCoreDefinitions) ID() string { 4497 return "OperationSerializer" 4498} 4499 4500func (m *awsRestjson1_serializeOpListCoreDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4501 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4502) { 4503 request, ok := in.Request.(*smithyhttp.Request) 4504 if !ok { 4505 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4506 } 4507 4508 input, ok := in.Parameters.(*ListCoreDefinitionsInput) 4509 _ = input 4510 if !ok { 4511 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4512 } 4513 4514 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores") 4515 request.URL.Path = opPath 4516 if len(request.URL.RawQuery) > 0 { 4517 request.URL.RawQuery = "&" + opQuery 4518 } else { 4519 request.URL.RawQuery = opQuery 4520 } 4521 4522 request.Method = "GET" 4523 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4524 if err != nil { 4525 return out, metadata, &smithy.SerializationError{Err: err} 4526 } 4527 4528 if err := awsRestjson1_serializeOpHttpBindingsListCoreDefinitionsInput(input, restEncoder); err != nil { 4529 return out, metadata, &smithy.SerializationError{Err: err} 4530 } 4531 4532 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4533 return out, metadata, &smithy.SerializationError{Err: err} 4534 } 4535 in.Request = request 4536 4537 return next.HandleSerialize(ctx, in) 4538} 4539func awsRestjson1_serializeOpHttpBindingsListCoreDefinitionsInput(v *ListCoreDefinitionsInput, encoder *httpbinding.Encoder) error { 4540 if v == nil { 4541 return fmt.Errorf("unsupported serialization of nil %T", v) 4542 } 4543 4544 if v.MaxResults != nil { 4545 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4546 } 4547 4548 if v.NextToken != nil { 4549 encoder.SetQuery("NextToken").String(*v.NextToken) 4550 } 4551 4552 return nil 4553} 4554 4555type awsRestjson1_serializeOpListCoreDefinitionVersions struct { 4556} 4557 4558func (*awsRestjson1_serializeOpListCoreDefinitionVersions) ID() string { 4559 return "OperationSerializer" 4560} 4561 4562func (m *awsRestjson1_serializeOpListCoreDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4563 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4564) { 4565 request, ok := in.Request.(*smithyhttp.Request) 4566 if !ok { 4567 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4568 } 4569 4570 input, ok := in.Parameters.(*ListCoreDefinitionVersionsInput) 4571 _ = input 4572 if !ok { 4573 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4574 } 4575 4576 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}/versions") 4577 request.URL.Path = opPath 4578 if len(request.URL.RawQuery) > 0 { 4579 request.URL.RawQuery = "&" + opQuery 4580 } else { 4581 request.URL.RawQuery = opQuery 4582 } 4583 4584 request.Method = "GET" 4585 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4586 if err != nil { 4587 return out, metadata, &smithy.SerializationError{Err: err} 4588 } 4589 4590 if err := awsRestjson1_serializeOpHttpBindingsListCoreDefinitionVersionsInput(input, restEncoder); err != nil { 4591 return out, metadata, &smithy.SerializationError{Err: err} 4592 } 4593 4594 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4595 return out, metadata, &smithy.SerializationError{Err: err} 4596 } 4597 in.Request = request 4598 4599 return next.HandleSerialize(ctx, in) 4600} 4601func awsRestjson1_serializeOpHttpBindingsListCoreDefinitionVersionsInput(v *ListCoreDefinitionVersionsInput, encoder *httpbinding.Encoder) error { 4602 if v == nil { 4603 return fmt.Errorf("unsupported serialization of nil %T", v) 4604 } 4605 4606 if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 { 4607 return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")} 4608 } 4609 if v.CoreDefinitionId != nil { 4610 if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil { 4611 return err 4612 } 4613 } 4614 4615 if v.MaxResults != nil { 4616 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4617 } 4618 4619 if v.NextToken != nil { 4620 encoder.SetQuery("NextToken").String(*v.NextToken) 4621 } 4622 4623 return nil 4624} 4625 4626type awsRestjson1_serializeOpListDeployments struct { 4627} 4628 4629func (*awsRestjson1_serializeOpListDeployments) ID() string { 4630 return "OperationSerializer" 4631} 4632 4633func (m *awsRestjson1_serializeOpListDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4634 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4635) { 4636 request, ok := in.Request.(*smithyhttp.Request) 4637 if !ok { 4638 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4639 } 4640 4641 input, ok := in.Parameters.(*ListDeploymentsInput) 4642 _ = input 4643 if !ok { 4644 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4645 } 4646 4647 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/deployments") 4648 request.URL.Path = opPath 4649 if len(request.URL.RawQuery) > 0 { 4650 request.URL.RawQuery = "&" + opQuery 4651 } else { 4652 request.URL.RawQuery = opQuery 4653 } 4654 4655 request.Method = "GET" 4656 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4657 if err != nil { 4658 return out, metadata, &smithy.SerializationError{Err: err} 4659 } 4660 4661 if err := awsRestjson1_serializeOpHttpBindingsListDeploymentsInput(input, restEncoder); err != nil { 4662 return out, metadata, &smithy.SerializationError{Err: err} 4663 } 4664 4665 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4666 return out, metadata, &smithy.SerializationError{Err: err} 4667 } 4668 in.Request = request 4669 4670 return next.HandleSerialize(ctx, in) 4671} 4672func awsRestjson1_serializeOpHttpBindingsListDeploymentsInput(v *ListDeploymentsInput, encoder *httpbinding.Encoder) error { 4673 if v == nil { 4674 return fmt.Errorf("unsupported serialization of nil %T", v) 4675 } 4676 4677 if v.GroupId == nil || len(*v.GroupId) == 0 { 4678 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 4679 } 4680 if v.GroupId != nil { 4681 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 4682 return err 4683 } 4684 } 4685 4686 if v.MaxResults != nil { 4687 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4688 } 4689 4690 if v.NextToken != nil { 4691 encoder.SetQuery("NextToken").String(*v.NextToken) 4692 } 4693 4694 return nil 4695} 4696 4697type awsRestjson1_serializeOpListDeviceDefinitions struct { 4698} 4699 4700func (*awsRestjson1_serializeOpListDeviceDefinitions) ID() string { 4701 return "OperationSerializer" 4702} 4703 4704func (m *awsRestjson1_serializeOpListDeviceDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4705 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4706) { 4707 request, ok := in.Request.(*smithyhttp.Request) 4708 if !ok { 4709 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4710 } 4711 4712 input, ok := in.Parameters.(*ListDeviceDefinitionsInput) 4713 _ = input 4714 if !ok { 4715 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4716 } 4717 4718 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices") 4719 request.URL.Path = opPath 4720 if len(request.URL.RawQuery) > 0 { 4721 request.URL.RawQuery = "&" + opQuery 4722 } else { 4723 request.URL.RawQuery = opQuery 4724 } 4725 4726 request.Method = "GET" 4727 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4728 if err != nil { 4729 return out, metadata, &smithy.SerializationError{Err: err} 4730 } 4731 4732 if err := awsRestjson1_serializeOpHttpBindingsListDeviceDefinitionsInput(input, restEncoder); err != nil { 4733 return out, metadata, &smithy.SerializationError{Err: err} 4734 } 4735 4736 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4737 return out, metadata, &smithy.SerializationError{Err: err} 4738 } 4739 in.Request = request 4740 4741 return next.HandleSerialize(ctx, in) 4742} 4743func awsRestjson1_serializeOpHttpBindingsListDeviceDefinitionsInput(v *ListDeviceDefinitionsInput, encoder *httpbinding.Encoder) error { 4744 if v == nil { 4745 return fmt.Errorf("unsupported serialization of nil %T", v) 4746 } 4747 4748 if v.MaxResults != nil { 4749 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4750 } 4751 4752 if v.NextToken != nil { 4753 encoder.SetQuery("NextToken").String(*v.NextToken) 4754 } 4755 4756 return nil 4757} 4758 4759type awsRestjson1_serializeOpListDeviceDefinitionVersions struct { 4760} 4761 4762func (*awsRestjson1_serializeOpListDeviceDefinitionVersions) ID() string { 4763 return "OperationSerializer" 4764} 4765 4766func (m *awsRestjson1_serializeOpListDeviceDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4767 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4768) { 4769 request, ok := in.Request.(*smithyhttp.Request) 4770 if !ok { 4771 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4772 } 4773 4774 input, ok := in.Parameters.(*ListDeviceDefinitionVersionsInput) 4775 _ = input 4776 if !ok { 4777 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4778 } 4779 4780 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}/versions") 4781 request.URL.Path = opPath 4782 if len(request.URL.RawQuery) > 0 { 4783 request.URL.RawQuery = "&" + opQuery 4784 } else { 4785 request.URL.RawQuery = opQuery 4786 } 4787 4788 request.Method = "GET" 4789 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4790 if err != nil { 4791 return out, metadata, &smithy.SerializationError{Err: err} 4792 } 4793 4794 if err := awsRestjson1_serializeOpHttpBindingsListDeviceDefinitionVersionsInput(input, restEncoder); err != nil { 4795 return out, metadata, &smithy.SerializationError{Err: err} 4796 } 4797 4798 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4799 return out, metadata, &smithy.SerializationError{Err: err} 4800 } 4801 in.Request = request 4802 4803 return next.HandleSerialize(ctx, in) 4804} 4805func awsRestjson1_serializeOpHttpBindingsListDeviceDefinitionVersionsInput(v *ListDeviceDefinitionVersionsInput, encoder *httpbinding.Encoder) error { 4806 if v == nil { 4807 return fmt.Errorf("unsupported serialization of nil %T", v) 4808 } 4809 4810 if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 { 4811 return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")} 4812 } 4813 if v.DeviceDefinitionId != nil { 4814 if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil { 4815 return err 4816 } 4817 } 4818 4819 if v.MaxResults != nil { 4820 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4821 } 4822 4823 if v.NextToken != nil { 4824 encoder.SetQuery("NextToken").String(*v.NextToken) 4825 } 4826 4827 return nil 4828} 4829 4830type awsRestjson1_serializeOpListFunctionDefinitions struct { 4831} 4832 4833func (*awsRestjson1_serializeOpListFunctionDefinitions) ID() string { 4834 return "OperationSerializer" 4835} 4836 4837func (m *awsRestjson1_serializeOpListFunctionDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4838 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4839) { 4840 request, ok := in.Request.(*smithyhttp.Request) 4841 if !ok { 4842 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4843 } 4844 4845 input, ok := in.Parameters.(*ListFunctionDefinitionsInput) 4846 _ = input 4847 if !ok { 4848 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4849 } 4850 4851 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions") 4852 request.URL.Path = opPath 4853 if len(request.URL.RawQuery) > 0 { 4854 request.URL.RawQuery = "&" + opQuery 4855 } else { 4856 request.URL.RawQuery = opQuery 4857 } 4858 4859 request.Method = "GET" 4860 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4861 if err != nil { 4862 return out, metadata, &smithy.SerializationError{Err: err} 4863 } 4864 4865 if err := awsRestjson1_serializeOpHttpBindingsListFunctionDefinitionsInput(input, restEncoder); err != nil { 4866 return out, metadata, &smithy.SerializationError{Err: err} 4867 } 4868 4869 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4870 return out, metadata, &smithy.SerializationError{Err: err} 4871 } 4872 in.Request = request 4873 4874 return next.HandleSerialize(ctx, in) 4875} 4876func awsRestjson1_serializeOpHttpBindingsListFunctionDefinitionsInput(v *ListFunctionDefinitionsInput, encoder *httpbinding.Encoder) error { 4877 if v == nil { 4878 return fmt.Errorf("unsupported serialization of nil %T", v) 4879 } 4880 4881 if v.MaxResults != nil { 4882 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4883 } 4884 4885 if v.NextToken != nil { 4886 encoder.SetQuery("NextToken").String(*v.NextToken) 4887 } 4888 4889 return nil 4890} 4891 4892type awsRestjson1_serializeOpListFunctionDefinitionVersions struct { 4893} 4894 4895func (*awsRestjson1_serializeOpListFunctionDefinitionVersions) ID() string { 4896 return "OperationSerializer" 4897} 4898 4899func (m *awsRestjson1_serializeOpListFunctionDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4900 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4901) { 4902 request, ok := in.Request.(*smithyhttp.Request) 4903 if !ok { 4904 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4905 } 4906 4907 input, ok := in.Parameters.(*ListFunctionDefinitionVersionsInput) 4908 _ = input 4909 if !ok { 4910 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4911 } 4912 4913 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}/versions") 4914 request.URL.Path = opPath 4915 if len(request.URL.RawQuery) > 0 { 4916 request.URL.RawQuery = "&" + opQuery 4917 } else { 4918 request.URL.RawQuery = opQuery 4919 } 4920 4921 request.Method = "GET" 4922 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4923 if err != nil { 4924 return out, metadata, &smithy.SerializationError{Err: err} 4925 } 4926 4927 if err := awsRestjson1_serializeOpHttpBindingsListFunctionDefinitionVersionsInput(input, restEncoder); err != nil { 4928 return out, metadata, &smithy.SerializationError{Err: err} 4929 } 4930 4931 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4932 return out, metadata, &smithy.SerializationError{Err: err} 4933 } 4934 in.Request = request 4935 4936 return next.HandleSerialize(ctx, in) 4937} 4938func awsRestjson1_serializeOpHttpBindingsListFunctionDefinitionVersionsInput(v *ListFunctionDefinitionVersionsInput, encoder *httpbinding.Encoder) error { 4939 if v == nil { 4940 return fmt.Errorf("unsupported serialization of nil %T", v) 4941 } 4942 4943 if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 { 4944 return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")} 4945 } 4946 if v.FunctionDefinitionId != nil { 4947 if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil { 4948 return err 4949 } 4950 } 4951 4952 if v.MaxResults != nil { 4953 encoder.SetQuery("MaxResults").String(*v.MaxResults) 4954 } 4955 4956 if v.NextToken != nil { 4957 encoder.SetQuery("NextToken").String(*v.NextToken) 4958 } 4959 4960 return nil 4961} 4962 4963type awsRestjson1_serializeOpListGroupCertificateAuthorities struct { 4964} 4965 4966func (*awsRestjson1_serializeOpListGroupCertificateAuthorities) ID() string { 4967 return "OperationSerializer" 4968} 4969 4970func (m *awsRestjson1_serializeOpListGroupCertificateAuthorities) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4971 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4972) { 4973 request, ok := in.Request.(*smithyhttp.Request) 4974 if !ok { 4975 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4976 } 4977 4978 input, ok := in.Parameters.(*ListGroupCertificateAuthoritiesInput) 4979 _ = input 4980 if !ok { 4981 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4982 } 4983 4984 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities") 4985 request.URL.Path = opPath 4986 if len(request.URL.RawQuery) > 0 { 4987 request.URL.RawQuery = "&" + opQuery 4988 } else { 4989 request.URL.RawQuery = opQuery 4990 } 4991 4992 request.Method = "GET" 4993 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4994 if err != nil { 4995 return out, metadata, &smithy.SerializationError{Err: err} 4996 } 4997 4998 if err := awsRestjson1_serializeOpHttpBindingsListGroupCertificateAuthoritiesInput(input, restEncoder); err != nil { 4999 return out, metadata, &smithy.SerializationError{Err: err} 5000 } 5001 5002 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5003 return out, metadata, &smithy.SerializationError{Err: err} 5004 } 5005 in.Request = request 5006 5007 return next.HandleSerialize(ctx, in) 5008} 5009func awsRestjson1_serializeOpHttpBindingsListGroupCertificateAuthoritiesInput(v *ListGroupCertificateAuthoritiesInput, encoder *httpbinding.Encoder) error { 5010 if v == nil { 5011 return fmt.Errorf("unsupported serialization of nil %T", v) 5012 } 5013 5014 if v.GroupId == nil || len(*v.GroupId) == 0 { 5015 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 5016 } 5017 if v.GroupId != nil { 5018 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 5019 return err 5020 } 5021 } 5022 5023 return nil 5024} 5025 5026type awsRestjson1_serializeOpListGroups struct { 5027} 5028 5029func (*awsRestjson1_serializeOpListGroups) ID() string { 5030 return "OperationSerializer" 5031} 5032 5033func (m *awsRestjson1_serializeOpListGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5034 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5035) { 5036 request, ok := in.Request.(*smithyhttp.Request) 5037 if !ok { 5038 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5039 } 5040 5041 input, ok := in.Parameters.(*ListGroupsInput) 5042 _ = input 5043 if !ok { 5044 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5045 } 5046 5047 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups") 5048 request.URL.Path = opPath 5049 if len(request.URL.RawQuery) > 0 { 5050 request.URL.RawQuery = "&" + opQuery 5051 } else { 5052 request.URL.RawQuery = opQuery 5053 } 5054 5055 request.Method = "GET" 5056 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5057 if err != nil { 5058 return out, metadata, &smithy.SerializationError{Err: err} 5059 } 5060 5061 if err := awsRestjson1_serializeOpHttpBindingsListGroupsInput(input, restEncoder); err != nil { 5062 return out, metadata, &smithy.SerializationError{Err: err} 5063 } 5064 5065 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5066 return out, metadata, &smithy.SerializationError{Err: err} 5067 } 5068 in.Request = request 5069 5070 return next.HandleSerialize(ctx, in) 5071} 5072func awsRestjson1_serializeOpHttpBindingsListGroupsInput(v *ListGroupsInput, encoder *httpbinding.Encoder) error { 5073 if v == nil { 5074 return fmt.Errorf("unsupported serialization of nil %T", v) 5075 } 5076 5077 if v.MaxResults != nil { 5078 encoder.SetQuery("MaxResults").String(*v.MaxResults) 5079 } 5080 5081 if v.NextToken != nil { 5082 encoder.SetQuery("NextToken").String(*v.NextToken) 5083 } 5084 5085 return nil 5086} 5087 5088type awsRestjson1_serializeOpListGroupVersions struct { 5089} 5090 5091func (*awsRestjson1_serializeOpListGroupVersions) ID() string { 5092 return "OperationSerializer" 5093} 5094 5095func (m *awsRestjson1_serializeOpListGroupVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5096 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5097) { 5098 request, ok := in.Request.(*smithyhttp.Request) 5099 if !ok { 5100 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5101 } 5102 5103 input, ok := in.Parameters.(*ListGroupVersionsInput) 5104 _ = input 5105 if !ok { 5106 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5107 } 5108 5109 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/versions") 5110 request.URL.Path = opPath 5111 if len(request.URL.RawQuery) > 0 { 5112 request.URL.RawQuery = "&" + opQuery 5113 } else { 5114 request.URL.RawQuery = opQuery 5115 } 5116 5117 request.Method = "GET" 5118 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5119 if err != nil { 5120 return out, metadata, &smithy.SerializationError{Err: err} 5121 } 5122 5123 if err := awsRestjson1_serializeOpHttpBindingsListGroupVersionsInput(input, restEncoder); err != nil { 5124 return out, metadata, &smithy.SerializationError{Err: err} 5125 } 5126 5127 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5128 return out, metadata, &smithy.SerializationError{Err: err} 5129 } 5130 in.Request = request 5131 5132 return next.HandleSerialize(ctx, in) 5133} 5134func awsRestjson1_serializeOpHttpBindingsListGroupVersionsInput(v *ListGroupVersionsInput, encoder *httpbinding.Encoder) error { 5135 if v == nil { 5136 return fmt.Errorf("unsupported serialization of nil %T", v) 5137 } 5138 5139 if v.GroupId == nil || len(*v.GroupId) == 0 { 5140 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 5141 } 5142 if v.GroupId != nil { 5143 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 5144 return err 5145 } 5146 } 5147 5148 if v.MaxResults != nil { 5149 encoder.SetQuery("MaxResults").String(*v.MaxResults) 5150 } 5151 5152 if v.NextToken != nil { 5153 encoder.SetQuery("NextToken").String(*v.NextToken) 5154 } 5155 5156 return nil 5157} 5158 5159type awsRestjson1_serializeOpListLoggerDefinitions struct { 5160} 5161 5162func (*awsRestjson1_serializeOpListLoggerDefinitions) ID() string { 5163 return "OperationSerializer" 5164} 5165 5166func (m *awsRestjson1_serializeOpListLoggerDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5167 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5168) { 5169 request, ok := in.Request.(*smithyhttp.Request) 5170 if !ok { 5171 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5172 } 5173 5174 input, ok := in.Parameters.(*ListLoggerDefinitionsInput) 5175 _ = input 5176 if !ok { 5177 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5178 } 5179 5180 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers") 5181 request.URL.Path = opPath 5182 if len(request.URL.RawQuery) > 0 { 5183 request.URL.RawQuery = "&" + opQuery 5184 } else { 5185 request.URL.RawQuery = opQuery 5186 } 5187 5188 request.Method = "GET" 5189 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5190 if err != nil { 5191 return out, metadata, &smithy.SerializationError{Err: err} 5192 } 5193 5194 if err := awsRestjson1_serializeOpHttpBindingsListLoggerDefinitionsInput(input, restEncoder); err != nil { 5195 return out, metadata, &smithy.SerializationError{Err: err} 5196 } 5197 5198 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5199 return out, metadata, &smithy.SerializationError{Err: err} 5200 } 5201 in.Request = request 5202 5203 return next.HandleSerialize(ctx, in) 5204} 5205func awsRestjson1_serializeOpHttpBindingsListLoggerDefinitionsInput(v *ListLoggerDefinitionsInput, encoder *httpbinding.Encoder) error { 5206 if v == nil { 5207 return fmt.Errorf("unsupported serialization of nil %T", v) 5208 } 5209 5210 if v.MaxResults != nil { 5211 encoder.SetQuery("MaxResults").String(*v.MaxResults) 5212 } 5213 5214 if v.NextToken != nil { 5215 encoder.SetQuery("NextToken").String(*v.NextToken) 5216 } 5217 5218 return nil 5219} 5220 5221type awsRestjson1_serializeOpListLoggerDefinitionVersions struct { 5222} 5223 5224func (*awsRestjson1_serializeOpListLoggerDefinitionVersions) ID() string { 5225 return "OperationSerializer" 5226} 5227 5228func (m *awsRestjson1_serializeOpListLoggerDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5229 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5230) { 5231 request, ok := in.Request.(*smithyhttp.Request) 5232 if !ok { 5233 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5234 } 5235 5236 input, ok := in.Parameters.(*ListLoggerDefinitionVersionsInput) 5237 _ = input 5238 if !ok { 5239 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5240 } 5241 5242 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}/versions") 5243 request.URL.Path = opPath 5244 if len(request.URL.RawQuery) > 0 { 5245 request.URL.RawQuery = "&" + opQuery 5246 } else { 5247 request.URL.RawQuery = opQuery 5248 } 5249 5250 request.Method = "GET" 5251 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5252 if err != nil { 5253 return out, metadata, &smithy.SerializationError{Err: err} 5254 } 5255 5256 if err := awsRestjson1_serializeOpHttpBindingsListLoggerDefinitionVersionsInput(input, restEncoder); err != nil { 5257 return out, metadata, &smithy.SerializationError{Err: err} 5258 } 5259 5260 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5261 return out, metadata, &smithy.SerializationError{Err: err} 5262 } 5263 in.Request = request 5264 5265 return next.HandleSerialize(ctx, in) 5266} 5267func awsRestjson1_serializeOpHttpBindingsListLoggerDefinitionVersionsInput(v *ListLoggerDefinitionVersionsInput, encoder *httpbinding.Encoder) error { 5268 if v == nil { 5269 return fmt.Errorf("unsupported serialization of nil %T", v) 5270 } 5271 5272 if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 { 5273 return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")} 5274 } 5275 if v.LoggerDefinitionId != nil { 5276 if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil { 5277 return err 5278 } 5279 } 5280 5281 if v.MaxResults != nil { 5282 encoder.SetQuery("MaxResults").String(*v.MaxResults) 5283 } 5284 5285 if v.NextToken != nil { 5286 encoder.SetQuery("NextToken").String(*v.NextToken) 5287 } 5288 5289 return nil 5290} 5291 5292type awsRestjson1_serializeOpListResourceDefinitions struct { 5293} 5294 5295func (*awsRestjson1_serializeOpListResourceDefinitions) ID() string { 5296 return "OperationSerializer" 5297} 5298 5299func (m *awsRestjson1_serializeOpListResourceDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5300 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5301) { 5302 request, ok := in.Request.(*smithyhttp.Request) 5303 if !ok { 5304 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5305 } 5306 5307 input, ok := in.Parameters.(*ListResourceDefinitionsInput) 5308 _ = input 5309 if !ok { 5310 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5311 } 5312 5313 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources") 5314 request.URL.Path = opPath 5315 if len(request.URL.RawQuery) > 0 { 5316 request.URL.RawQuery = "&" + opQuery 5317 } else { 5318 request.URL.RawQuery = opQuery 5319 } 5320 5321 request.Method = "GET" 5322 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5323 if err != nil { 5324 return out, metadata, &smithy.SerializationError{Err: err} 5325 } 5326 5327 if err := awsRestjson1_serializeOpHttpBindingsListResourceDefinitionsInput(input, restEncoder); err != nil { 5328 return out, metadata, &smithy.SerializationError{Err: err} 5329 } 5330 5331 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5332 return out, metadata, &smithy.SerializationError{Err: err} 5333 } 5334 in.Request = request 5335 5336 return next.HandleSerialize(ctx, in) 5337} 5338func awsRestjson1_serializeOpHttpBindingsListResourceDefinitionsInput(v *ListResourceDefinitionsInput, encoder *httpbinding.Encoder) error { 5339 if v == nil { 5340 return fmt.Errorf("unsupported serialization of nil %T", v) 5341 } 5342 5343 if v.MaxResults != nil { 5344 encoder.SetQuery("MaxResults").String(*v.MaxResults) 5345 } 5346 5347 if v.NextToken != nil { 5348 encoder.SetQuery("NextToken").String(*v.NextToken) 5349 } 5350 5351 return nil 5352} 5353 5354type awsRestjson1_serializeOpListResourceDefinitionVersions struct { 5355} 5356 5357func (*awsRestjson1_serializeOpListResourceDefinitionVersions) ID() string { 5358 return "OperationSerializer" 5359} 5360 5361func (m *awsRestjson1_serializeOpListResourceDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5362 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5363) { 5364 request, ok := in.Request.(*smithyhttp.Request) 5365 if !ok { 5366 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5367 } 5368 5369 input, ok := in.Parameters.(*ListResourceDefinitionVersionsInput) 5370 _ = input 5371 if !ok { 5372 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5373 } 5374 5375 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}/versions") 5376 request.URL.Path = opPath 5377 if len(request.URL.RawQuery) > 0 { 5378 request.URL.RawQuery = "&" + opQuery 5379 } else { 5380 request.URL.RawQuery = opQuery 5381 } 5382 5383 request.Method = "GET" 5384 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5385 if err != nil { 5386 return out, metadata, &smithy.SerializationError{Err: err} 5387 } 5388 5389 if err := awsRestjson1_serializeOpHttpBindingsListResourceDefinitionVersionsInput(input, restEncoder); err != nil { 5390 return out, metadata, &smithy.SerializationError{Err: err} 5391 } 5392 5393 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5394 return out, metadata, &smithy.SerializationError{Err: err} 5395 } 5396 in.Request = request 5397 5398 return next.HandleSerialize(ctx, in) 5399} 5400func awsRestjson1_serializeOpHttpBindingsListResourceDefinitionVersionsInput(v *ListResourceDefinitionVersionsInput, encoder *httpbinding.Encoder) error { 5401 if v == nil { 5402 return fmt.Errorf("unsupported serialization of nil %T", v) 5403 } 5404 5405 if v.MaxResults != nil { 5406 encoder.SetQuery("MaxResults").String(*v.MaxResults) 5407 } 5408 5409 if v.NextToken != nil { 5410 encoder.SetQuery("NextToken").String(*v.NextToken) 5411 } 5412 5413 if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 { 5414 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")} 5415 } 5416 if v.ResourceDefinitionId != nil { 5417 if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil { 5418 return err 5419 } 5420 } 5421 5422 return nil 5423} 5424 5425type awsRestjson1_serializeOpListSubscriptionDefinitions struct { 5426} 5427 5428func (*awsRestjson1_serializeOpListSubscriptionDefinitions) ID() string { 5429 return "OperationSerializer" 5430} 5431 5432func (m *awsRestjson1_serializeOpListSubscriptionDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5433 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5434) { 5435 request, ok := in.Request.(*smithyhttp.Request) 5436 if !ok { 5437 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5438 } 5439 5440 input, ok := in.Parameters.(*ListSubscriptionDefinitionsInput) 5441 _ = input 5442 if !ok { 5443 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5444 } 5445 5446 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions") 5447 request.URL.Path = opPath 5448 if len(request.URL.RawQuery) > 0 { 5449 request.URL.RawQuery = "&" + opQuery 5450 } else { 5451 request.URL.RawQuery = opQuery 5452 } 5453 5454 request.Method = "GET" 5455 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5456 if err != nil { 5457 return out, metadata, &smithy.SerializationError{Err: err} 5458 } 5459 5460 if err := awsRestjson1_serializeOpHttpBindingsListSubscriptionDefinitionsInput(input, restEncoder); err != nil { 5461 return out, metadata, &smithy.SerializationError{Err: err} 5462 } 5463 5464 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5465 return out, metadata, &smithy.SerializationError{Err: err} 5466 } 5467 in.Request = request 5468 5469 return next.HandleSerialize(ctx, in) 5470} 5471func awsRestjson1_serializeOpHttpBindingsListSubscriptionDefinitionsInput(v *ListSubscriptionDefinitionsInput, encoder *httpbinding.Encoder) error { 5472 if v == nil { 5473 return fmt.Errorf("unsupported serialization of nil %T", v) 5474 } 5475 5476 if v.MaxResults != nil { 5477 encoder.SetQuery("MaxResults").String(*v.MaxResults) 5478 } 5479 5480 if v.NextToken != nil { 5481 encoder.SetQuery("NextToken").String(*v.NextToken) 5482 } 5483 5484 return nil 5485} 5486 5487type awsRestjson1_serializeOpListSubscriptionDefinitionVersions struct { 5488} 5489 5490func (*awsRestjson1_serializeOpListSubscriptionDefinitionVersions) ID() string { 5491 return "OperationSerializer" 5492} 5493 5494func (m *awsRestjson1_serializeOpListSubscriptionDefinitionVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5495 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5496) { 5497 request, ok := in.Request.(*smithyhttp.Request) 5498 if !ok { 5499 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5500 } 5501 5502 input, ok := in.Parameters.(*ListSubscriptionDefinitionVersionsInput) 5503 _ = input 5504 if !ok { 5505 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5506 } 5507 5508 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions") 5509 request.URL.Path = opPath 5510 if len(request.URL.RawQuery) > 0 { 5511 request.URL.RawQuery = "&" + opQuery 5512 } else { 5513 request.URL.RawQuery = opQuery 5514 } 5515 5516 request.Method = "GET" 5517 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5518 if err != nil { 5519 return out, metadata, &smithy.SerializationError{Err: err} 5520 } 5521 5522 if err := awsRestjson1_serializeOpHttpBindingsListSubscriptionDefinitionVersionsInput(input, restEncoder); err != nil { 5523 return out, metadata, &smithy.SerializationError{Err: err} 5524 } 5525 5526 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5527 return out, metadata, &smithy.SerializationError{Err: err} 5528 } 5529 in.Request = request 5530 5531 return next.HandleSerialize(ctx, in) 5532} 5533func awsRestjson1_serializeOpHttpBindingsListSubscriptionDefinitionVersionsInput(v *ListSubscriptionDefinitionVersionsInput, encoder *httpbinding.Encoder) error { 5534 if v == nil { 5535 return fmt.Errorf("unsupported serialization of nil %T", v) 5536 } 5537 5538 if v.MaxResults != nil { 5539 encoder.SetQuery("MaxResults").String(*v.MaxResults) 5540 } 5541 5542 if v.NextToken != nil { 5543 encoder.SetQuery("NextToken").String(*v.NextToken) 5544 } 5545 5546 if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 { 5547 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")} 5548 } 5549 if v.SubscriptionDefinitionId != nil { 5550 if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil { 5551 return err 5552 } 5553 } 5554 5555 return nil 5556} 5557 5558type awsRestjson1_serializeOpListTagsForResource struct { 5559} 5560 5561func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 5562 return "OperationSerializer" 5563} 5564 5565func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5566 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5567) { 5568 request, ok := in.Request.(*smithyhttp.Request) 5569 if !ok { 5570 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5571 } 5572 5573 input, ok := in.Parameters.(*ListTagsForResourceInput) 5574 _ = input 5575 if !ok { 5576 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5577 } 5578 5579 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 5580 request.URL.Path = opPath 5581 if len(request.URL.RawQuery) > 0 { 5582 request.URL.RawQuery = "&" + opQuery 5583 } else { 5584 request.URL.RawQuery = opQuery 5585 } 5586 5587 request.Method = "GET" 5588 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5589 if err != nil { 5590 return out, metadata, &smithy.SerializationError{Err: err} 5591 } 5592 5593 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 5594 return out, metadata, &smithy.SerializationError{Err: err} 5595 } 5596 5597 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5598 return out, metadata, &smithy.SerializationError{Err: err} 5599 } 5600 in.Request = request 5601 5602 return next.HandleSerialize(ctx, in) 5603} 5604func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 5605 if v == nil { 5606 return fmt.Errorf("unsupported serialization of nil %T", v) 5607 } 5608 5609 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 5610 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 5611 } 5612 if v.ResourceArn != nil { 5613 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 5614 return err 5615 } 5616 } 5617 5618 return nil 5619} 5620 5621type awsRestjson1_serializeOpResetDeployments struct { 5622} 5623 5624func (*awsRestjson1_serializeOpResetDeployments) ID() string { 5625 return "OperationSerializer" 5626} 5627 5628func (m *awsRestjson1_serializeOpResetDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5629 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5630) { 5631 request, ok := in.Request.(*smithyhttp.Request) 5632 if !ok { 5633 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5634 } 5635 5636 input, ok := in.Parameters.(*ResetDeploymentsInput) 5637 _ = input 5638 if !ok { 5639 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5640 } 5641 5642 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/deployments/$reset") 5643 request.URL.Path = opPath 5644 if len(request.URL.RawQuery) > 0 { 5645 request.URL.RawQuery = "&" + opQuery 5646 } else { 5647 request.URL.RawQuery = opQuery 5648 } 5649 5650 request.Method = "POST" 5651 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5652 if err != nil { 5653 return out, metadata, &smithy.SerializationError{Err: err} 5654 } 5655 5656 if err := awsRestjson1_serializeOpHttpBindingsResetDeploymentsInput(input, restEncoder); err != nil { 5657 return out, metadata, &smithy.SerializationError{Err: err} 5658 } 5659 5660 restEncoder.SetHeader("Content-Type").String("application/json") 5661 5662 jsonEncoder := smithyjson.NewEncoder() 5663 if err := awsRestjson1_serializeOpDocumentResetDeploymentsInput(input, jsonEncoder.Value); err != nil { 5664 return out, metadata, &smithy.SerializationError{Err: err} 5665 } 5666 5667 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5668 return out, metadata, &smithy.SerializationError{Err: err} 5669 } 5670 5671 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5672 return out, metadata, &smithy.SerializationError{Err: err} 5673 } 5674 in.Request = request 5675 5676 return next.HandleSerialize(ctx, in) 5677} 5678func awsRestjson1_serializeOpHttpBindingsResetDeploymentsInput(v *ResetDeploymentsInput, encoder *httpbinding.Encoder) error { 5679 if v == nil { 5680 return fmt.Errorf("unsupported serialization of nil %T", v) 5681 } 5682 5683 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 5684 locationName := "X-Amzn-Client-Token" 5685 encoder.SetHeader(locationName).String(*v.AmznClientToken) 5686 } 5687 5688 if v.GroupId == nil || len(*v.GroupId) == 0 { 5689 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 5690 } 5691 if v.GroupId != nil { 5692 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 5693 return err 5694 } 5695 } 5696 5697 return nil 5698} 5699 5700func awsRestjson1_serializeOpDocumentResetDeploymentsInput(v *ResetDeploymentsInput, value smithyjson.Value) error { 5701 object := value.Object() 5702 defer object.Close() 5703 5704 if v.Force { 5705 ok := object.Key("Force") 5706 ok.Boolean(v.Force) 5707 } 5708 5709 return nil 5710} 5711 5712type awsRestjson1_serializeOpStartBulkDeployment struct { 5713} 5714 5715func (*awsRestjson1_serializeOpStartBulkDeployment) ID() string { 5716 return "OperationSerializer" 5717} 5718 5719func (m *awsRestjson1_serializeOpStartBulkDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5720 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5721) { 5722 request, ok := in.Request.(*smithyhttp.Request) 5723 if !ok { 5724 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5725 } 5726 5727 input, ok := in.Parameters.(*StartBulkDeploymentInput) 5728 _ = input 5729 if !ok { 5730 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5731 } 5732 5733 opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments") 5734 request.URL.Path = opPath 5735 if len(request.URL.RawQuery) > 0 { 5736 request.URL.RawQuery = "&" + opQuery 5737 } else { 5738 request.URL.RawQuery = opQuery 5739 } 5740 5741 request.Method = "POST" 5742 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5743 if err != nil { 5744 return out, metadata, &smithy.SerializationError{Err: err} 5745 } 5746 5747 if err := awsRestjson1_serializeOpHttpBindingsStartBulkDeploymentInput(input, restEncoder); err != nil { 5748 return out, metadata, &smithy.SerializationError{Err: err} 5749 } 5750 5751 restEncoder.SetHeader("Content-Type").String("application/json") 5752 5753 jsonEncoder := smithyjson.NewEncoder() 5754 if err := awsRestjson1_serializeOpDocumentStartBulkDeploymentInput(input, jsonEncoder.Value); err != nil { 5755 return out, metadata, &smithy.SerializationError{Err: err} 5756 } 5757 5758 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5759 return out, metadata, &smithy.SerializationError{Err: err} 5760 } 5761 5762 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5763 return out, metadata, &smithy.SerializationError{Err: err} 5764 } 5765 in.Request = request 5766 5767 return next.HandleSerialize(ctx, in) 5768} 5769func awsRestjson1_serializeOpHttpBindingsStartBulkDeploymentInput(v *StartBulkDeploymentInput, encoder *httpbinding.Encoder) error { 5770 if v == nil { 5771 return fmt.Errorf("unsupported serialization of nil %T", v) 5772 } 5773 5774 if v.AmznClientToken != nil && len(*v.AmznClientToken) > 0 { 5775 locationName := "X-Amzn-Client-Token" 5776 encoder.SetHeader(locationName).String(*v.AmznClientToken) 5777 } 5778 5779 return nil 5780} 5781 5782func awsRestjson1_serializeOpDocumentStartBulkDeploymentInput(v *StartBulkDeploymentInput, value smithyjson.Value) error { 5783 object := value.Object() 5784 defer object.Close() 5785 5786 if v.ExecutionRoleArn != nil { 5787 ok := object.Key("ExecutionRoleArn") 5788 ok.String(*v.ExecutionRoleArn) 5789 } 5790 5791 if v.InputFileUri != nil { 5792 ok := object.Key("InputFileUri") 5793 ok.String(*v.InputFileUri) 5794 } 5795 5796 if v.Tags != nil { 5797 ok := object.Key("tags") 5798 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 5799 return err 5800 } 5801 } 5802 5803 return nil 5804} 5805 5806type awsRestjson1_serializeOpStopBulkDeployment struct { 5807} 5808 5809func (*awsRestjson1_serializeOpStopBulkDeployment) ID() string { 5810 return "OperationSerializer" 5811} 5812 5813func (m *awsRestjson1_serializeOpStopBulkDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5814 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5815) { 5816 request, ok := in.Request.(*smithyhttp.Request) 5817 if !ok { 5818 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5819 } 5820 5821 input, ok := in.Parameters.(*StopBulkDeploymentInput) 5822 _ = input 5823 if !ok { 5824 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5825 } 5826 5827 opPath, opQuery := httpbinding.SplitURI("/greengrass/bulk/deployments/{BulkDeploymentId}/$stop") 5828 request.URL.Path = opPath 5829 if len(request.URL.RawQuery) > 0 { 5830 request.URL.RawQuery = "&" + opQuery 5831 } else { 5832 request.URL.RawQuery = opQuery 5833 } 5834 5835 request.Method = "PUT" 5836 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5837 if err != nil { 5838 return out, metadata, &smithy.SerializationError{Err: err} 5839 } 5840 5841 if err := awsRestjson1_serializeOpHttpBindingsStopBulkDeploymentInput(input, restEncoder); err != nil { 5842 return out, metadata, &smithy.SerializationError{Err: err} 5843 } 5844 5845 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5846 return out, metadata, &smithy.SerializationError{Err: err} 5847 } 5848 in.Request = request 5849 5850 return next.HandleSerialize(ctx, in) 5851} 5852func awsRestjson1_serializeOpHttpBindingsStopBulkDeploymentInput(v *StopBulkDeploymentInput, encoder *httpbinding.Encoder) error { 5853 if v == nil { 5854 return fmt.Errorf("unsupported serialization of nil %T", v) 5855 } 5856 5857 if v.BulkDeploymentId == nil || len(*v.BulkDeploymentId) == 0 { 5858 return &smithy.SerializationError{Err: fmt.Errorf("input member BulkDeploymentId must not be empty")} 5859 } 5860 if v.BulkDeploymentId != nil { 5861 if err := encoder.SetURI("BulkDeploymentId").String(*v.BulkDeploymentId); err != nil { 5862 return err 5863 } 5864 } 5865 5866 return nil 5867} 5868 5869type awsRestjson1_serializeOpTagResource struct { 5870} 5871 5872func (*awsRestjson1_serializeOpTagResource) ID() string { 5873 return "OperationSerializer" 5874} 5875 5876func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5877 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5878) { 5879 request, ok := in.Request.(*smithyhttp.Request) 5880 if !ok { 5881 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5882 } 5883 5884 input, ok := in.Parameters.(*TagResourceInput) 5885 _ = input 5886 if !ok { 5887 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5888 } 5889 5890 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 5891 request.URL.Path = opPath 5892 if len(request.URL.RawQuery) > 0 { 5893 request.URL.RawQuery = "&" + opQuery 5894 } else { 5895 request.URL.RawQuery = opQuery 5896 } 5897 5898 request.Method = "POST" 5899 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5900 if err != nil { 5901 return out, metadata, &smithy.SerializationError{Err: err} 5902 } 5903 5904 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 5905 return out, metadata, &smithy.SerializationError{Err: err} 5906 } 5907 5908 restEncoder.SetHeader("Content-Type").String("application/json") 5909 5910 jsonEncoder := smithyjson.NewEncoder() 5911 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 5912 return out, metadata, &smithy.SerializationError{Err: err} 5913 } 5914 5915 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5916 return out, metadata, &smithy.SerializationError{Err: err} 5917 } 5918 5919 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5920 return out, metadata, &smithy.SerializationError{Err: err} 5921 } 5922 in.Request = request 5923 5924 return next.HandleSerialize(ctx, in) 5925} 5926func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 5927 if v == nil { 5928 return fmt.Errorf("unsupported serialization of nil %T", v) 5929 } 5930 5931 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 5932 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 5933 } 5934 if v.ResourceArn != nil { 5935 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 5936 return err 5937 } 5938 } 5939 5940 return nil 5941} 5942 5943func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 5944 object := value.Object() 5945 defer object.Close() 5946 5947 if v.Tags != nil { 5948 ok := object.Key("tags") 5949 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 5950 return err 5951 } 5952 } 5953 5954 return nil 5955} 5956 5957type awsRestjson1_serializeOpUntagResource struct { 5958} 5959 5960func (*awsRestjson1_serializeOpUntagResource) ID() string { 5961 return "OperationSerializer" 5962} 5963 5964func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5965 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5966) { 5967 request, ok := in.Request.(*smithyhttp.Request) 5968 if !ok { 5969 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5970 } 5971 5972 input, ok := in.Parameters.(*UntagResourceInput) 5973 _ = input 5974 if !ok { 5975 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5976 } 5977 5978 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 5979 request.URL.Path = opPath 5980 if len(request.URL.RawQuery) > 0 { 5981 request.URL.RawQuery = "&" + opQuery 5982 } else { 5983 request.URL.RawQuery = opQuery 5984 } 5985 5986 request.Method = "DELETE" 5987 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5988 if err != nil { 5989 return out, metadata, &smithy.SerializationError{Err: err} 5990 } 5991 5992 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 5993 return out, metadata, &smithy.SerializationError{Err: err} 5994 } 5995 5996 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5997 return out, metadata, &smithy.SerializationError{Err: err} 5998 } 5999 in.Request = request 6000 6001 return next.HandleSerialize(ctx, in) 6002} 6003func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 6004 if v == nil { 6005 return fmt.Errorf("unsupported serialization of nil %T", v) 6006 } 6007 6008 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 6009 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 6010 } 6011 if v.ResourceArn != nil { 6012 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 6013 return err 6014 } 6015 } 6016 6017 if v.TagKeys != nil { 6018 for i := range v.TagKeys { 6019 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 6020 } 6021 } 6022 6023 return nil 6024} 6025 6026type awsRestjson1_serializeOpUpdateConnectivityInfo struct { 6027} 6028 6029func (*awsRestjson1_serializeOpUpdateConnectivityInfo) ID() string { 6030 return "OperationSerializer" 6031} 6032 6033func (m *awsRestjson1_serializeOpUpdateConnectivityInfo) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6034 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6035) { 6036 request, ok := in.Request.(*smithyhttp.Request) 6037 if !ok { 6038 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6039 } 6040 6041 input, ok := in.Parameters.(*UpdateConnectivityInfoInput) 6042 _ = input 6043 if !ok { 6044 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6045 } 6046 6047 opPath, opQuery := httpbinding.SplitURI("/greengrass/things/{ThingName}/connectivityInfo") 6048 request.URL.Path = opPath 6049 if len(request.URL.RawQuery) > 0 { 6050 request.URL.RawQuery = "&" + opQuery 6051 } else { 6052 request.URL.RawQuery = opQuery 6053 } 6054 6055 request.Method = "PUT" 6056 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6057 if err != nil { 6058 return out, metadata, &smithy.SerializationError{Err: err} 6059 } 6060 6061 if err := awsRestjson1_serializeOpHttpBindingsUpdateConnectivityInfoInput(input, restEncoder); err != nil { 6062 return out, metadata, &smithy.SerializationError{Err: err} 6063 } 6064 6065 restEncoder.SetHeader("Content-Type").String("application/json") 6066 6067 jsonEncoder := smithyjson.NewEncoder() 6068 if err := awsRestjson1_serializeOpDocumentUpdateConnectivityInfoInput(input, jsonEncoder.Value); err != nil { 6069 return out, metadata, &smithy.SerializationError{Err: err} 6070 } 6071 6072 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6073 return out, metadata, &smithy.SerializationError{Err: err} 6074 } 6075 6076 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6077 return out, metadata, &smithy.SerializationError{Err: err} 6078 } 6079 in.Request = request 6080 6081 return next.HandleSerialize(ctx, in) 6082} 6083func awsRestjson1_serializeOpHttpBindingsUpdateConnectivityInfoInput(v *UpdateConnectivityInfoInput, encoder *httpbinding.Encoder) error { 6084 if v == nil { 6085 return fmt.Errorf("unsupported serialization of nil %T", v) 6086 } 6087 6088 if v.ThingName == nil || len(*v.ThingName) == 0 { 6089 return &smithy.SerializationError{Err: fmt.Errorf("input member ThingName must not be empty")} 6090 } 6091 if v.ThingName != nil { 6092 if err := encoder.SetURI("ThingName").String(*v.ThingName); err != nil { 6093 return err 6094 } 6095 } 6096 6097 return nil 6098} 6099 6100func awsRestjson1_serializeOpDocumentUpdateConnectivityInfoInput(v *UpdateConnectivityInfoInput, value smithyjson.Value) error { 6101 object := value.Object() 6102 defer object.Close() 6103 6104 if v.ConnectivityInfo != nil { 6105 ok := object.Key("ConnectivityInfo") 6106 if err := awsRestjson1_serializeDocument__listOfConnectivityInfo(v.ConnectivityInfo, ok); err != nil { 6107 return err 6108 } 6109 } 6110 6111 return nil 6112} 6113 6114type awsRestjson1_serializeOpUpdateConnectorDefinition struct { 6115} 6116 6117func (*awsRestjson1_serializeOpUpdateConnectorDefinition) ID() string { 6118 return "OperationSerializer" 6119} 6120 6121func (m *awsRestjson1_serializeOpUpdateConnectorDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6122 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6123) { 6124 request, ok := in.Request.(*smithyhttp.Request) 6125 if !ok { 6126 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6127 } 6128 6129 input, ok := in.Parameters.(*UpdateConnectorDefinitionInput) 6130 _ = input 6131 if !ok { 6132 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6133 } 6134 6135 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/connectors/{ConnectorDefinitionId}") 6136 request.URL.Path = opPath 6137 if len(request.URL.RawQuery) > 0 { 6138 request.URL.RawQuery = "&" + opQuery 6139 } else { 6140 request.URL.RawQuery = opQuery 6141 } 6142 6143 request.Method = "PUT" 6144 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6145 if err != nil { 6146 return out, metadata, &smithy.SerializationError{Err: err} 6147 } 6148 6149 if err := awsRestjson1_serializeOpHttpBindingsUpdateConnectorDefinitionInput(input, restEncoder); err != nil { 6150 return out, metadata, &smithy.SerializationError{Err: err} 6151 } 6152 6153 restEncoder.SetHeader("Content-Type").String("application/json") 6154 6155 jsonEncoder := smithyjson.NewEncoder() 6156 if err := awsRestjson1_serializeOpDocumentUpdateConnectorDefinitionInput(input, jsonEncoder.Value); err != nil { 6157 return out, metadata, &smithy.SerializationError{Err: err} 6158 } 6159 6160 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6161 return out, metadata, &smithy.SerializationError{Err: err} 6162 } 6163 6164 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6165 return out, metadata, &smithy.SerializationError{Err: err} 6166 } 6167 in.Request = request 6168 6169 return next.HandleSerialize(ctx, in) 6170} 6171func awsRestjson1_serializeOpHttpBindingsUpdateConnectorDefinitionInput(v *UpdateConnectorDefinitionInput, encoder *httpbinding.Encoder) error { 6172 if v == nil { 6173 return fmt.Errorf("unsupported serialization of nil %T", v) 6174 } 6175 6176 if v.ConnectorDefinitionId == nil || len(*v.ConnectorDefinitionId) == 0 { 6177 return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectorDefinitionId must not be empty")} 6178 } 6179 if v.ConnectorDefinitionId != nil { 6180 if err := encoder.SetURI("ConnectorDefinitionId").String(*v.ConnectorDefinitionId); err != nil { 6181 return err 6182 } 6183 } 6184 6185 return nil 6186} 6187 6188func awsRestjson1_serializeOpDocumentUpdateConnectorDefinitionInput(v *UpdateConnectorDefinitionInput, value smithyjson.Value) error { 6189 object := value.Object() 6190 defer object.Close() 6191 6192 if v.Name != nil { 6193 ok := object.Key("Name") 6194 ok.String(*v.Name) 6195 } 6196 6197 return nil 6198} 6199 6200type awsRestjson1_serializeOpUpdateCoreDefinition struct { 6201} 6202 6203func (*awsRestjson1_serializeOpUpdateCoreDefinition) ID() string { 6204 return "OperationSerializer" 6205} 6206 6207func (m *awsRestjson1_serializeOpUpdateCoreDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6208 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6209) { 6210 request, ok := in.Request.(*smithyhttp.Request) 6211 if !ok { 6212 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6213 } 6214 6215 input, ok := in.Parameters.(*UpdateCoreDefinitionInput) 6216 _ = input 6217 if !ok { 6218 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6219 } 6220 6221 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/cores/{CoreDefinitionId}") 6222 request.URL.Path = opPath 6223 if len(request.URL.RawQuery) > 0 { 6224 request.URL.RawQuery = "&" + opQuery 6225 } else { 6226 request.URL.RawQuery = opQuery 6227 } 6228 6229 request.Method = "PUT" 6230 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6231 if err != nil { 6232 return out, metadata, &smithy.SerializationError{Err: err} 6233 } 6234 6235 if err := awsRestjson1_serializeOpHttpBindingsUpdateCoreDefinitionInput(input, restEncoder); err != nil { 6236 return out, metadata, &smithy.SerializationError{Err: err} 6237 } 6238 6239 restEncoder.SetHeader("Content-Type").String("application/json") 6240 6241 jsonEncoder := smithyjson.NewEncoder() 6242 if err := awsRestjson1_serializeOpDocumentUpdateCoreDefinitionInput(input, jsonEncoder.Value); err != nil { 6243 return out, metadata, &smithy.SerializationError{Err: err} 6244 } 6245 6246 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6247 return out, metadata, &smithy.SerializationError{Err: err} 6248 } 6249 6250 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6251 return out, metadata, &smithy.SerializationError{Err: err} 6252 } 6253 in.Request = request 6254 6255 return next.HandleSerialize(ctx, in) 6256} 6257func awsRestjson1_serializeOpHttpBindingsUpdateCoreDefinitionInput(v *UpdateCoreDefinitionInput, encoder *httpbinding.Encoder) error { 6258 if v == nil { 6259 return fmt.Errorf("unsupported serialization of nil %T", v) 6260 } 6261 6262 if v.CoreDefinitionId == nil || len(*v.CoreDefinitionId) == 0 { 6263 return &smithy.SerializationError{Err: fmt.Errorf("input member CoreDefinitionId must not be empty")} 6264 } 6265 if v.CoreDefinitionId != nil { 6266 if err := encoder.SetURI("CoreDefinitionId").String(*v.CoreDefinitionId); err != nil { 6267 return err 6268 } 6269 } 6270 6271 return nil 6272} 6273 6274func awsRestjson1_serializeOpDocumentUpdateCoreDefinitionInput(v *UpdateCoreDefinitionInput, value smithyjson.Value) error { 6275 object := value.Object() 6276 defer object.Close() 6277 6278 if v.Name != nil { 6279 ok := object.Key("Name") 6280 ok.String(*v.Name) 6281 } 6282 6283 return nil 6284} 6285 6286type awsRestjson1_serializeOpUpdateDeviceDefinition struct { 6287} 6288 6289func (*awsRestjson1_serializeOpUpdateDeviceDefinition) ID() string { 6290 return "OperationSerializer" 6291} 6292 6293func (m *awsRestjson1_serializeOpUpdateDeviceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6294 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6295) { 6296 request, ok := in.Request.(*smithyhttp.Request) 6297 if !ok { 6298 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6299 } 6300 6301 input, ok := in.Parameters.(*UpdateDeviceDefinitionInput) 6302 _ = input 6303 if !ok { 6304 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6305 } 6306 6307 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/devices/{DeviceDefinitionId}") 6308 request.URL.Path = opPath 6309 if len(request.URL.RawQuery) > 0 { 6310 request.URL.RawQuery = "&" + opQuery 6311 } else { 6312 request.URL.RawQuery = opQuery 6313 } 6314 6315 request.Method = "PUT" 6316 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6317 if err != nil { 6318 return out, metadata, &smithy.SerializationError{Err: err} 6319 } 6320 6321 if err := awsRestjson1_serializeOpHttpBindingsUpdateDeviceDefinitionInput(input, restEncoder); err != nil { 6322 return out, metadata, &smithy.SerializationError{Err: err} 6323 } 6324 6325 restEncoder.SetHeader("Content-Type").String("application/json") 6326 6327 jsonEncoder := smithyjson.NewEncoder() 6328 if err := awsRestjson1_serializeOpDocumentUpdateDeviceDefinitionInput(input, jsonEncoder.Value); err != nil { 6329 return out, metadata, &smithy.SerializationError{Err: err} 6330 } 6331 6332 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6333 return out, metadata, &smithy.SerializationError{Err: err} 6334 } 6335 6336 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6337 return out, metadata, &smithy.SerializationError{Err: err} 6338 } 6339 in.Request = request 6340 6341 return next.HandleSerialize(ctx, in) 6342} 6343func awsRestjson1_serializeOpHttpBindingsUpdateDeviceDefinitionInput(v *UpdateDeviceDefinitionInput, encoder *httpbinding.Encoder) error { 6344 if v == nil { 6345 return fmt.Errorf("unsupported serialization of nil %T", v) 6346 } 6347 6348 if v.DeviceDefinitionId == nil || len(*v.DeviceDefinitionId) == 0 { 6349 return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceDefinitionId must not be empty")} 6350 } 6351 if v.DeviceDefinitionId != nil { 6352 if err := encoder.SetURI("DeviceDefinitionId").String(*v.DeviceDefinitionId); err != nil { 6353 return err 6354 } 6355 } 6356 6357 return nil 6358} 6359 6360func awsRestjson1_serializeOpDocumentUpdateDeviceDefinitionInput(v *UpdateDeviceDefinitionInput, value smithyjson.Value) error { 6361 object := value.Object() 6362 defer object.Close() 6363 6364 if v.Name != nil { 6365 ok := object.Key("Name") 6366 ok.String(*v.Name) 6367 } 6368 6369 return nil 6370} 6371 6372type awsRestjson1_serializeOpUpdateFunctionDefinition struct { 6373} 6374 6375func (*awsRestjson1_serializeOpUpdateFunctionDefinition) ID() string { 6376 return "OperationSerializer" 6377} 6378 6379func (m *awsRestjson1_serializeOpUpdateFunctionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6380 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6381) { 6382 request, ok := in.Request.(*smithyhttp.Request) 6383 if !ok { 6384 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6385 } 6386 6387 input, ok := in.Parameters.(*UpdateFunctionDefinitionInput) 6388 _ = input 6389 if !ok { 6390 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6391 } 6392 6393 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/functions/{FunctionDefinitionId}") 6394 request.URL.Path = opPath 6395 if len(request.URL.RawQuery) > 0 { 6396 request.URL.RawQuery = "&" + opQuery 6397 } else { 6398 request.URL.RawQuery = opQuery 6399 } 6400 6401 request.Method = "PUT" 6402 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6403 if err != nil { 6404 return out, metadata, &smithy.SerializationError{Err: err} 6405 } 6406 6407 if err := awsRestjson1_serializeOpHttpBindingsUpdateFunctionDefinitionInput(input, restEncoder); err != nil { 6408 return out, metadata, &smithy.SerializationError{Err: err} 6409 } 6410 6411 restEncoder.SetHeader("Content-Type").String("application/json") 6412 6413 jsonEncoder := smithyjson.NewEncoder() 6414 if err := awsRestjson1_serializeOpDocumentUpdateFunctionDefinitionInput(input, jsonEncoder.Value); err != nil { 6415 return out, metadata, &smithy.SerializationError{Err: err} 6416 } 6417 6418 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6419 return out, metadata, &smithy.SerializationError{Err: err} 6420 } 6421 6422 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6423 return out, metadata, &smithy.SerializationError{Err: err} 6424 } 6425 in.Request = request 6426 6427 return next.HandleSerialize(ctx, in) 6428} 6429func awsRestjson1_serializeOpHttpBindingsUpdateFunctionDefinitionInput(v *UpdateFunctionDefinitionInput, encoder *httpbinding.Encoder) error { 6430 if v == nil { 6431 return fmt.Errorf("unsupported serialization of nil %T", v) 6432 } 6433 6434 if v.FunctionDefinitionId == nil || len(*v.FunctionDefinitionId) == 0 { 6435 return &smithy.SerializationError{Err: fmt.Errorf("input member FunctionDefinitionId must not be empty")} 6436 } 6437 if v.FunctionDefinitionId != nil { 6438 if err := encoder.SetURI("FunctionDefinitionId").String(*v.FunctionDefinitionId); err != nil { 6439 return err 6440 } 6441 } 6442 6443 return nil 6444} 6445 6446func awsRestjson1_serializeOpDocumentUpdateFunctionDefinitionInput(v *UpdateFunctionDefinitionInput, value smithyjson.Value) error { 6447 object := value.Object() 6448 defer object.Close() 6449 6450 if v.Name != nil { 6451 ok := object.Key("Name") 6452 ok.String(*v.Name) 6453 } 6454 6455 return nil 6456} 6457 6458type awsRestjson1_serializeOpUpdateGroup struct { 6459} 6460 6461func (*awsRestjson1_serializeOpUpdateGroup) ID() string { 6462 return "OperationSerializer" 6463} 6464 6465func (m *awsRestjson1_serializeOpUpdateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6466 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6467) { 6468 request, ok := in.Request.(*smithyhttp.Request) 6469 if !ok { 6470 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6471 } 6472 6473 input, ok := in.Parameters.(*UpdateGroupInput) 6474 _ = input 6475 if !ok { 6476 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6477 } 6478 6479 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}") 6480 request.URL.Path = opPath 6481 if len(request.URL.RawQuery) > 0 { 6482 request.URL.RawQuery = "&" + opQuery 6483 } else { 6484 request.URL.RawQuery = opQuery 6485 } 6486 6487 request.Method = "PUT" 6488 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6489 if err != nil { 6490 return out, metadata, &smithy.SerializationError{Err: err} 6491 } 6492 6493 if err := awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(input, restEncoder); err != nil { 6494 return out, metadata, &smithy.SerializationError{Err: err} 6495 } 6496 6497 restEncoder.SetHeader("Content-Type").String("application/json") 6498 6499 jsonEncoder := smithyjson.NewEncoder() 6500 if err := awsRestjson1_serializeOpDocumentUpdateGroupInput(input, jsonEncoder.Value); err != nil { 6501 return out, metadata, &smithy.SerializationError{Err: err} 6502 } 6503 6504 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6505 return out, metadata, &smithy.SerializationError{Err: err} 6506 } 6507 6508 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6509 return out, metadata, &smithy.SerializationError{Err: err} 6510 } 6511 in.Request = request 6512 6513 return next.HandleSerialize(ctx, in) 6514} 6515func awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(v *UpdateGroupInput, encoder *httpbinding.Encoder) error { 6516 if v == nil { 6517 return fmt.Errorf("unsupported serialization of nil %T", v) 6518 } 6519 6520 if v.GroupId == nil || len(*v.GroupId) == 0 { 6521 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 6522 } 6523 if v.GroupId != nil { 6524 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 6525 return err 6526 } 6527 } 6528 6529 return nil 6530} 6531 6532func awsRestjson1_serializeOpDocumentUpdateGroupInput(v *UpdateGroupInput, value smithyjson.Value) error { 6533 object := value.Object() 6534 defer object.Close() 6535 6536 if v.Name != nil { 6537 ok := object.Key("Name") 6538 ok.String(*v.Name) 6539 } 6540 6541 return nil 6542} 6543 6544type awsRestjson1_serializeOpUpdateGroupCertificateConfiguration struct { 6545} 6546 6547func (*awsRestjson1_serializeOpUpdateGroupCertificateConfiguration) ID() string { 6548 return "OperationSerializer" 6549} 6550 6551func (m *awsRestjson1_serializeOpUpdateGroupCertificateConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6552 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6553) { 6554 request, ok := in.Request.(*smithyhttp.Request) 6555 if !ok { 6556 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6557 } 6558 6559 input, ok := in.Parameters.(*UpdateGroupCertificateConfigurationInput) 6560 _ = input 6561 if !ok { 6562 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6563 } 6564 6565 opPath, opQuery := httpbinding.SplitURI("/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry") 6566 request.URL.Path = opPath 6567 if len(request.URL.RawQuery) > 0 { 6568 request.URL.RawQuery = "&" + opQuery 6569 } else { 6570 request.URL.RawQuery = opQuery 6571 } 6572 6573 request.Method = "PUT" 6574 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6575 if err != nil { 6576 return out, metadata, &smithy.SerializationError{Err: err} 6577 } 6578 6579 if err := awsRestjson1_serializeOpHttpBindingsUpdateGroupCertificateConfigurationInput(input, restEncoder); err != nil { 6580 return out, metadata, &smithy.SerializationError{Err: err} 6581 } 6582 6583 restEncoder.SetHeader("Content-Type").String("application/json") 6584 6585 jsonEncoder := smithyjson.NewEncoder() 6586 if err := awsRestjson1_serializeOpDocumentUpdateGroupCertificateConfigurationInput(input, jsonEncoder.Value); err != nil { 6587 return out, metadata, &smithy.SerializationError{Err: err} 6588 } 6589 6590 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6591 return out, metadata, &smithy.SerializationError{Err: err} 6592 } 6593 6594 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6595 return out, metadata, &smithy.SerializationError{Err: err} 6596 } 6597 in.Request = request 6598 6599 return next.HandleSerialize(ctx, in) 6600} 6601func awsRestjson1_serializeOpHttpBindingsUpdateGroupCertificateConfigurationInput(v *UpdateGroupCertificateConfigurationInput, encoder *httpbinding.Encoder) error { 6602 if v == nil { 6603 return fmt.Errorf("unsupported serialization of nil %T", v) 6604 } 6605 6606 if v.GroupId == nil || len(*v.GroupId) == 0 { 6607 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupId must not be empty")} 6608 } 6609 if v.GroupId != nil { 6610 if err := encoder.SetURI("GroupId").String(*v.GroupId); err != nil { 6611 return err 6612 } 6613 } 6614 6615 return nil 6616} 6617 6618func awsRestjson1_serializeOpDocumentUpdateGroupCertificateConfigurationInput(v *UpdateGroupCertificateConfigurationInput, value smithyjson.Value) error { 6619 object := value.Object() 6620 defer object.Close() 6621 6622 if v.CertificateExpiryInMilliseconds != nil { 6623 ok := object.Key("CertificateExpiryInMilliseconds") 6624 ok.String(*v.CertificateExpiryInMilliseconds) 6625 } 6626 6627 return nil 6628} 6629 6630type awsRestjson1_serializeOpUpdateLoggerDefinition struct { 6631} 6632 6633func (*awsRestjson1_serializeOpUpdateLoggerDefinition) ID() string { 6634 return "OperationSerializer" 6635} 6636 6637func (m *awsRestjson1_serializeOpUpdateLoggerDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6638 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6639) { 6640 request, ok := in.Request.(*smithyhttp.Request) 6641 if !ok { 6642 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6643 } 6644 6645 input, ok := in.Parameters.(*UpdateLoggerDefinitionInput) 6646 _ = input 6647 if !ok { 6648 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6649 } 6650 6651 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/loggers/{LoggerDefinitionId}") 6652 request.URL.Path = opPath 6653 if len(request.URL.RawQuery) > 0 { 6654 request.URL.RawQuery = "&" + opQuery 6655 } else { 6656 request.URL.RawQuery = opQuery 6657 } 6658 6659 request.Method = "PUT" 6660 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6661 if err != nil { 6662 return out, metadata, &smithy.SerializationError{Err: err} 6663 } 6664 6665 if err := awsRestjson1_serializeOpHttpBindingsUpdateLoggerDefinitionInput(input, restEncoder); err != nil { 6666 return out, metadata, &smithy.SerializationError{Err: err} 6667 } 6668 6669 restEncoder.SetHeader("Content-Type").String("application/json") 6670 6671 jsonEncoder := smithyjson.NewEncoder() 6672 if err := awsRestjson1_serializeOpDocumentUpdateLoggerDefinitionInput(input, jsonEncoder.Value); err != nil { 6673 return out, metadata, &smithy.SerializationError{Err: err} 6674 } 6675 6676 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6677 return out, metadata, &smithy.SerializationError{Err: err} 6678 } 6679 6680 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6681 return out, metadata, &smithy.SerializationError{Err: err} 6682 } 6683 in.Request = request 6684 6685 return next.HandleSerialize(ctx, in) 6686} 6687func awsRestjson1_serializeOpHttpBindingsUpdateLoggerDefinitionInput(v *UpdateLoggerDefinitionInput, encoder *httpbinding.Encoder) error { 6688 if v == nil { 6689 return fmt.Errorf("unsupported serialization of nil %T", v) 6690 } 6691 6692 if v.LoggerDefinitionId == nil || len(*v.LoggerDefinitionId) == 0 { 6693 return &smithy.SerializationError{Err: fmt.Errorf("input member LoggerDefinitionId must not be empty")} 6694 } 6695 if v.LoggerDefinitionId != nil { 6696 if err := encoder.SetURI("LoggerDefinitionId").String(*v.LoggerDefinitionId); err != nil { 6697 return err 6698 } 6699 } 6700 6701 return nil 6702} 6703 6704func awsRestjson1_serializeOpDocumentUpdateLoggerDefinitionInput(v *UpdateLoggerDefinitionInput, value smithyjson.Value) error { 6705 object := value.Object() 6706 defer object.Close() 6707 6708 if v.Name != nil { 6709 ok := object.Key("Name") 6710 ok.String(*v.Name) 6711 } 6712 6713 return nil 6714} 6715 6716type awsRestjson1_serializeOpUpdateResourceDefinition struct { 6717} 6718 6719func (*awsRestjson1_serializeOpUpdateResourceDefinition) ID() string { 6720 return "OperationSerializer" 6721} 6722 6723func (m *awsRestjson1_serializeOpUpdateResourceDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6724 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6725) { 6726 request, ok := in.Request.(*smithyhttp.Request) 6727 if !ok { 6728 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6729 } 6730 6731 input, ok := in.Parameters.(*UpdateResourceDefinitionInput) 6732 _ = input 6733 if !ok { 6734 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6735 } 6736 6737 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/resources/{ResourceDefinitionId}") 6738 request.URL.Path = opPath 6739 if len(request.URL.RawQuery) > 0 { 6740 request.URL.RawQuery = "&" + opQuery 6741 } else { 6742 request.URL.RawQuery = opQuery 6743 } 6744 6745 request.Method = "PUT" 6746 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6747 if err != nil { 6748 return out, metadata, &smithy.SerializationError{Err: err} 6749 } 6750 6751 if err := awsRestjson1_serializeOpHttpBindingsUpdateResourceDefinitionInput(input, restEncoder); err != nil { 6752 return out, metadata, &smithy.SerializationError{Err: err} 6753 } 6754 6755 restEncoder.SetHeader("Content-Type").String("application/json") 6756 6757 jsonEncoder := smithyjson.NewEncoder() 6758 if err := awsRestjson1_serializeOpDocumentUpdateResourceDefinitionInput(input, jsonEncoder.Value); err != nil { 6759 return out, metadata, &smithy.SerializationError{Err: err} 6760 } 6761 6762 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6763 return out, metadata, &smithy.SerializationError{Err: err} 6764 } 6765 6766 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6767 return out, metadata, &smithy.SerializationError{Err: err} 6768 } 6769 in.Request = request 6770 6771 return next.HandleSerialize(ctx, in) 6772} 6773func awsRestjson1_serializeOpHttpBindingsUpdateResourceDefinitionInput(v *UpdateResourceDefinitionInput, encoder *httpbinding.Encoder) error { 6774 if v == nil { 6775 return fmt.Errorf("unsupported serialization of nil %T", v) 6776 } 6777 6778 if v.ResourceDefinitionId == nil || len(*v.ResourceDefinitionId) == 0 { 6779 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceDefinitionId must not be empty")} 6780 } 6781 if v.ResourceDefinitionId != nil { 6782 if err := encoder.SetURI("ResourceDefinitionId").String(*v.ResourceDefinitionId); err != nil { 6783 return err 6784 } 6785 } 6786 6787 return nil 6788} 6789 6790func awsRestjson1_serializeOpDocumentUpdateResourceDefinitionInput(v *UpdateResourceDefinitionInput, value smithyjson.Value) error { 6791 object := value.Object() 6792 defer object.Close() 6793 6794 if v.Name != nil { 6795 ok := object.Key("Name") 6796 ok.String(*v.Name) 6797 } 6798 6799 return nil 6800} 6801 6802type awsRestjson1_serializeOpUpdateSubscriptionDefinition struct { 6803} 6804 6805func (*awsRestjson1_serializeOpUpdateSubscriptionDefinition) ID() string { 6806 return "OperationSerializer" 6807} 6808 6809func (m *awsRestjson1_serializeOpUpdateSubscriptionDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6810 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6811) { 6812 request, ok := in.Request.(*smithyhttp.Request) 6813 if !ok { 6814 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6815 } 6816 6817 input, ok := in.Parameters.(*UpdateSubscriptionDefinitionInput) 6818 _ = input 6819 if !ok { 6820 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6821 } 6822 6823 opPath, opQuery := httpbinding.SplitURI("/greengrass/definition/subscriptions/{SubscriptionDefinitionId}") 6824 request.URL.Path = opPath 6825 if len(request.URL.RawQuery) > 0 { 6826 request.URL.RawQuery = "&" + opQuery 6827 } else { 6828 request.URL.RawQuery = opQuery 6829 } 6830 6831 request.Method = "PUT" 6832 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6833 if err != nil { 6834 return out, metadata, &smithy.SerializationError{Err: err} 6835 } 6836 6837 if err := awsRestjson1_serializeOpHttpBindingsUpdateSubscriptionDefinitionInput(input, restEncoder); err != nil { 6838 return out, metadata, &smithy.SerializationError{Err: err} 6839 } 6840 6841 restEncoder.SetHeader("Content-Type").String("application/json") 6842 6843 jsonEncoder := smithyjson.NewEncoder() 6844 if err := awsRestjson1_serializeOpDocumentUpdateSubscriptionDefinitionInput(input, jsonEncoder.Value); err != nil { 6845 return out, metadata, &smithy.SerializationError{Err: err} 6846 } 6847 6848 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6849 return out, metadata, &smithy.SerializationError{Err: err} 6850 } 6851 6852 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6853 return out, metadata, &smithy.SerializationError{Err: err} 6854 } 6855 in.Request = request 6856 6857 return next.HandleSerialize(ctx, in) 6858} 6859func awsRestjson1_serializeOpHttpBindingsUpdateSubscriptionDefinitionInput(v *UpdateSubscriptionDefinitionInput, encoder *httpbinding.Encoder) error { 6860 if v == nil { 6861 return fmt.Errorf("unsupported serialization of nil %T", v) 6862 } 6863 6864 if v.SubscriptionDefinitionId == nil || len(*v.SubscriptionDefinitionId) == 0 { 6865 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscriptionDefinitionId must not be empty")} 6866 } 6867 if v.SubscriptionDefinitionId != nil { 6868 if err := encoder.SetURI("SubscriptionDefinitionId").String(*v.SubscriptionDefinitionId); err != nil { 6869 return err 6870 } 6871 } 6872 6873 return nil 6874} 6875 6876func awsRestjson1_serializeOpDocumentUpdateSubscriptionDefinitionInput(v *UpdateSubscriptionDefinitionInput, value smithyjson.Value) error { 6877 object := value.Object() 6878 defer object.Close() 6879 6880 if v.Name != nil { 6881 ok := object.Key("Name") 6882 ok.String(*v.Name) 6883 } 6884 6885 return nil 6886} 6887 6888type awsRestjson1_serializeOpUpdateThingRuntimeConfiguration struct { 6889} 6890 6891func (*awsRestjson1_serializeOpUpdateThingRuntimeConfiguration) ID() string { 6892 return "OperationSerializer" 6893} 6894 6895func (m *awsRestjson1_serializeOpUpdateThingRuntimeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6896 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6897) { 6898 request, ok := in.Request.(*smithyhttp.Request) 6899 if !ok { 6900 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6901 } 6902 6903 input, ok := in.Parameters.(*UpdateThingRuntimeConfigurationInput) 6904 _ = input 6905 if !ok { 6906 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6907 } 6908 6909 opPath, opQuery := httpbinding.SplitURI("/greengrass/things/{ThingName}/runtimeconfig") 6910 request.URL.Path = opPath 6911 if len(request.URL.RawQuery) > 0 { 6912 request.URL.RawQuery = "&" + opQuery 6913 } else { 6914 request.URL.RawQuery = opQuery 6915 } 6916 6917 request.Method = "PUT" 6918 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6919 if err != nil { 6920 return out, metadata, &smithy.SerializationError{Err: err} 6921 } 6922 6923 if err := awsRestjson1_serializeOpHttpBindingsUpdateThingRuntimeConfigurationInput(input, restEncoder); err != nil { 6924 return out, metadata, &smithy.SerializationError{Err: err} 6925 } 6926 6927 restEncoder.SetHeader("Content-Type").String("application/json") 6928 6929 jsonEncoder := smithyjson.NewEncoder() 6930 if err := awsRestjson1_serializeOpDocumentUpdateThingRuntimeConfigurationInput(input, jsonEncoder.Value); err != nil { 6931 return out, metadata, &smithy.SerializationError{Err: err} 6932 } 6933 6934 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6935 return out, metadata, &smithy.SerializationError{Err: err} 6936 } 6937 6938 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6939 return out, metadata, &smithy.SerializationError{Err: err} 6940 } 6941 in.Request = request 6942 6943 return next.HandleSerialize(ctx, in) 6944} 6945func awsRestjson1_serializeOpHttpBindingsUpdateThingRuntimeConfigurationInput(v *UpdateThingRuntimeConfigurationInput, encoder *httpbinding.Encoder) error { 6946 if v == nil { 6947 return fmt.Errorf("unsupported serialization of nil %T", v) 6948 } 6949 6950 if v.ThingName == nil || len(*v.ThingName) == 0 { 6951 return &smithy.SerializationError{Err: fmt.Errorf("input member ThingName must not be empty")} 6952 } 6953 if v.ThingName != nil { 6954 if err := encoder.SetURI("ThingName").String(*v.ThingName); err != nil { 6955 return err 6956 } 6957 } 6958 6959 return nil 6960} 6961 6962func awsRestjson1_serializeOpDocumentUpdateThingRuntimeConfigurationInput(v *UpdateThingRuntimeConfigurationInput, value smithyjson.Value) error { 6963 object := value.Object() 6964 defer object.Close() 6965 6966 if v.TelemetryConfiguration != nil { 6967 ok := object.Key("TelemetryConfiguration") 6968 if err := awsRestjson1_serializeDocumentTelemetryConfigurationUpdate(v.TelemetryConfiguration, ok); err != nil { 6969 return err 6970 } 6971 } 6972 6973 return nil 6974} 6975 6976func awsRestjson1_serializeDocument__listOf__string(v []string, value smithyjson.Value) error { 6977 array := value.Array() 6978 defer array.Close() 6979 6980 for i := range v { 6981 av := array.Value() 6982 av.String(v[i]) 6983 } 6984 return nil 6985} 6986 6987func awsRestjson1_serializeDocument__listOfConnectivityInfo(v []types.ConnectivityInfo, value smithyjson.Value) error { 6988 array := value.Array() 6989 defer array.Close() 6990 6991 for i := range v { 6992 av := array.Value() 6993 if err := awsRestjson1_serializeDocumentConnectivityInfo(&v[i], av); err != nil { 6994 return err 6995 } 6996 } 6997 return nil 6998} 6999 7000func awsRestjson1_serializeDocument__listOfConnector(v []types.Connector, value smithyjson.Value) error { 7001 array := value.Array() 7002 defer array.Close() 7003 7004 for i := range v { 7005 av := array.Value() 7006 if err := awsRestjson1_serializeDocumentConnector(&v[i], av); err != nil { 7007 return err 7008 } 7009 } 7010 return nil 7011} 7012 7013func awsRestjson1_serializeDocument__listOfCore(v []types.Core, value smithyjson.Value) error { 7014 array := value.Array() 7015 defer array.Close() 7016 7017 for i := range v { 7018 av := array.Value() 7019 if err := awsRestjson1_serializeDocumentCore(&v[i], av); err != nil { 7020 return err 7021 } 7022 } 7023 return nil 7024} 7025 7026func awsRestjson1_serializeDocument__listOfDevice(v []types.Device, value smithyjson.Value) error { 7027 array := value.Array() 7028 defer array.Close() 7029 7030 for i := range v { 7031 av := array.Value() 7032 if err := awsRestjson1_serializeDocumentDevice(&v[i], av); err != nil { 7033 return err 7034 } 7035 } 7036 return nil 7037} 7038 7039func awsRestjson1_serializeDocument__listOfFunction(v []types.Function, value smithyjson.Value) error { 7040 array := value.Array() 7041 defer array.Close() 7042 7043 for i := range v { 7044 av := array.Value() 7045 if err := awsRestjson1_serializeDocumentFunction(&v[i], av); err != nil { 7046 return err 7047 } 7048 } 7049 return nil 7050} 7051 7052func awsRestjson1_serializeDocument__listOfLogger(v []types.Logger, value smithyjson.Value) error { 7053 array := value.Array() 7054 defer array.Close() 7055 7056 for i := range v { 7057 av := array.Value() 7058 if err := awsRestjson1_serializeDocumentLogger(&v[i], av); err != nil { 7059 return err 7060 } 7061 } 7062 return nil 7063} 7064 7065func awsRestjson1_serializeDocument__listOfResource(v []types.Resource, value smithyjson.Value) error { 7066 array := value.Array() 7067 defer array.Close() 7068 7069 for i := range v { 7070 av := array.Value() 7071 if err := awsRestjson1_serializeDocumentResource(&v[i], av); err != nil { 7072 return err 7073 } 7074 } 7075 return nil 7076} 7077 7078func awsRestjson1_serializeDocument__listOfResourceAccessPolicy(v []types.ResourceAccessPolicy, value smithyjson.Value) error { 7079 array := value.Array() 7080 defer array.Close() 7081 7082 for i := range v { 7083 av := array.Value() 7084 if err := awsRestjson1_serializeDocumentResourceAccessPolicy(&v[i], av); err != nil { 7085 return err 7086 } 7087 } 7088 return nil 7089} 7090 7091func awsRestjson1_serializeDocument__listOfSubscription(v []types.Subscription, value smithyjson.Value) error { 7092 array := value.Array() 7093 defer array.Close() 7094 7095 for i := range v { 7096 av := array.Value() 7097 if err := awsRestjson1_serializeDocumentSubscription(&v[i], av); err != nil { 7098 return err 7099 } 7100 } 7101 return nil 7102} 7103 7104func awsRestjson1_serializeDocument__mapOf__string(v map[string]string, value smithyjson.Value) error { 7105 object := value.Object() 7106 defer object.Close() 7107 7108 for key := range v { 7109 om := object.Key(key) 7110 om.String(v[key]) 7111 } 7112 return nil 7113} 7114 7115func awsRestjson1_serializeDocumentConnectivityInfo(v *types.ConnectivityInfo, value smithyjson.Value) error { 7116 object := value.Object() 7117 defer object.Close() 7118 7119 if v.HostAddress != nil { 7120 ok := object.Key("HostAddress") 7121 ok.String(*v.HostAddress) 7122 } 7123 7124 if v.Id != nil { 7125 ok := object.Key("Id") 7126 ok.String(*v.Id) 7127 } 7128 7129 if v.Metadata != nil { 7130 ok := object.Key("Metadata") 7131 ok.String(*v.Metadata) 7132 } 7133 7134 if v.PortNumber != 0 { 7135 ok := object.Key("PortNumber") 7136 ok.Integer(v.PortNumber) 7137 } 7138 7139 return nil 7140} 7141 7142func awsRestjson1_serializeDocumentConnector(v *types.Connector, value smithyjson.Value) error { 7143 object := value.Object() 7144 defer object.Close() 7145 7146 if v.ConnectorArn != nil { 7147 ok := object.Key("ConnectorArn") 7148 ok.String(*v.ConnectorArn) 7149 } 7150 7151 if v.Id != nil { 7152 ok := object.Key("Id") 7153 ok.String(*v.Id) 7154 } 7155 7156 if v.Parameters != nil { 7157 ok := object.Key("Parameters") 7158 if err := awsRestjson1_serializeDocument__mapOf__string(v.Parameters, ok); err != nil { 7159 return err 7160 } 7161 } 7162 7163 return nil 7164} 7165 7166func awsRestjson1_serializeDocumentConnectorDefinitionVersion(v *types.ConnectorDefinitionVersion, value smithyjson.Value) error { 7167 object := value.Object() 7168 defer object.Close() 7169 7170 if v.Connectors != nil { 7171 ok := object.Key("Connectors") 7172 if err := awsRestjson1_serializeDocument__listOfConnector(v.Connectors, ok); err != nil { 7173 return err 7174 } 7175 } 7176 7177 return nil 7178} 7179 7180func awsRestjson1_serializeDocumentCore(v *types.Core, value smithyjson.Value) error { 7181 object := value.Object() 7182 defer object.Close() 7183 7184 if v.CertificateArn != nil { 7185 ok := object.Key("CertificateArn") 7186 ok.String(*v.CertificateArn) 7187 } 7188 7189 if v.Id != nil { 7190 ok := object.Key("Id") 7191 ok.String(*v.Id) 7192 } 7193 7194 if v.SyncShadow { 7195 ok := object.Key("SyncShadow") 7196 ok.Boolean(v.SyncShadow) 7197 } 7198 7199 if v.ThingArn != nil { 7200 ok := object.Key("ThingArn") 7201 ok.String(*v.ThingArn) 7202 } 7203 7204 return nil 7205} 7206 7207func awsRestjson1_serializeDocumentCoreDefinitionVersion(v *types.CoreDefinitionVersion, value smithyjson.Value) error { 7208 object := value.Object() 7209 defer object.Close() 7210 7211 if v.Cores != nil { 7212 ok := object.Key("Cores") 7213 if err := awsRestjson1_serializeDocument__listOfCore(v.Cores, ok); err != nil { 7214 return err 7215 } 7216 } 7217 7218 return nil 7219} 7220 7221func awsRestjson1_serializeDocumentDevice(v *types.Device, value smithyjson.Value) error { 7222 object := value.Object() 7223 defer object.Close() 7224 7225 if v.CertificateArn != nil { 7226 ok := object.Key("CertificateArn") 7227 ok.String(*v.CertificateArn) 7228 } 7229 7230 if v.Id != nil { 7231 ok := object.Key("Id") 7232 ok.String(*v.Id) 7233 } 7234 7235 if v.SyncShadow { 7236 ok := object.Key("SyncShadow") 7237 ok.Boolean(v.SyncShadow) 7238 } 7239 7240 if v.ThingArn != nil { 7241 ok := object.Key("ThingArn") 7242 ok.String(*v.ThingArn) 7243 } 7244 7245 return nil 7246} 7247 7248func awsRestjson1_serializeDocumentDeviceDefinitionVersion(v *types.DeviceDefinitionVersion, value smithyjson.Value) error { 7249 object := value.Object() 7250 defer object.Close() 7251 7252 if v.Devices != nil { 7253 ok := object.Key("Devices") 7254 if err := awsRestjson1_serializeDocument__listOfDevice(v.Devices, ok); err != nil { 7255 return err 7256 } 7257 } 7258 7259 return nil 7260} 7261 7262func awsRestjson1_serializeDocumentFunction(v *types.Function, value smithyjson.Value) error { 7263 object := value.Object() 7264 defer object.Close() 7265 7266 if v.FunctionArn != nil { 7267 ok := object.Key("FunctionArn") 7268 ok.String(*v.FunctionArn) 7269 } 7270 7271 if v.FunctionConfiguration != nil { 7272 ok := object.Key("FunctionConfiguration") 7273 if err := awsRestjson1_serializeDocumentFunctionConfiguration(v.FunctionConfiguration, ok); err != nil { 7274 return err 7275 } 7276 } 7277 7278 if v.Id != nil { 7279 ok := object.Key("Id") 7280 ok.String(*v.Id) 7281 } 7282 7283 return nil 7284} 7285 7286func awsRestjson1_serializeDocumentFunctionConfiguration(v *types.FunctionConfiguration, value smithyjson.Value) error { 7287 object := value.Object() 7288 defer object.Close() 7289 7290 if len(v.EncodingType) > 0 { 7291 ok := object.Key("EncodingType") 7292 ok.String(string(v.EncodingType)) 7293 } 7294 7295 if v.Environment != nil { 7296 ok := object.Key("Environment") 7297 if err := awsRestjson1_serializeDocumentFunctionConfigurationEnvironment(v.Environment, ok); err != nil { 7298 return err 7299 } 7300 } 7301 7302 if v.ExecArgs != nil { 7303 ok := object.Key("ExecArgs") 7304 ok.String(*v.ExecArgs) 7305 } 7306 7307 if v.Executable != nil { 7308 ok := object.Key("Executable") 7309 ok.String(*v.Executable) 7310 } 7311 7312 if v.MemorySize != 0 { 7313 ok := object.Key("MemorySize") 7314 ok.Integer(v.MemorySize) 7315 } 7316 7317 if v.Pinned { 7318 ok := object.Key("Pinned") 7319 ok.Boolean(v.Pinned) 7320 } 7321 7322 if v.Timeout != 0 { 7323 ok := object.Key("Timeout") 7324 ok.Integer(v.Timeout) 7325 } 7326 7327 return nil 7328} 7329 7330func awsRestjson1_serializeDocumentFunctionConfigurationEnvironment(v *types.FunctionConfigurationEnvironment, value smithyjson.Value) error { 7331 object := value.Object() 7332 defer object.Close() 7333 7334 if v.AccessSysfs { 7335 ok := object.Key("AccessSysfs") 7336 ok.Boolean(v.AccessSysfs) 7337 } 7338 7339 if v.Execution != nil { 7340 ok := object.Key("Execution") 7341 if err := awsRestjson1_serializeDocumentFunctionExecutionConfig(v.Execution, ok); err != nil { 7342 return err 7343 } 7344 } 7345 7346 if v.ResourceAccessPolicies != nil { 7347 ok := object.Key("ResourceAccessPolicies") 7348 if err := awsRestjson1_serializeDocument__listOfResourceAccessPolicy(v.ResourceAccessPolicies, ok); err != nil { 7349 return err 7350 } 7351 } 7352 7353 if v.Variables != nil { 7354 ok := object.Key("Variables") 7355 if err := awsRestjson1_serializeDocument__mapOf__string(v.Variables, ok); err != nil { 7356 return err 7357 } 7358 } 7359 7360 return nil 7361} 7362 7363func awsRestjson1_serializeDocumentFunctionDefaultConfig(v *types.FunctionDefaultConfig, value smithyjson.Value) error { 7364 object := value.Object() 7365 defer object.Close() 7366 7367 if v.Execution != nil { 7368 ok := object.Key("Execution") 7369 if err := awsRestjson1_serializeDocumentFunctionDefaultExecutionConfig(v.Execution, ok); err != nil { 7370 return err 7371 } 7372 } 7373 7374 return nil 7375} 7376 7377func awsRestjson1_serializeDocumentFunctionDefaultExecutionConfig(v *types.FunctionDefaultExecutionConfig, value smithyjson.Value) error { 7378 object := value.Object() 7379 defer object.Close() 7380 7381 if len(v.IsolationMode) > 0 { 7382 ok := object.Key("IsolationMode") 7383 ok.String(string(v.IsolationMode)) 7384 } 7385 7386 if v.RunAs != nil { 7387 ok := object.Key("RunAs") 7388 if err := awsRestjson1_serializeDocumentFunctionRunAsConfig(v.RunAs, ok); err != nil { 7389 return err 7390 } 7391 } 7392 7393 return nil 7394} 7395 7396func awsRestjson1_serializeDocumentFunctionDefinitionVersion(v *types.FunctionDefinitionVersion, value smithyjson.Value) error { 7397 object := value.Object() 7398 defer object.Close() 7399 7400 if v.DefaultConfig != nil { 7401 ok := object.Key("DefaultConfig") 7402 if err := awsRestjson1_serializeDocumentFunctionDefaultConfig(v.DefaultConfig, ok); err != nil { 7403 return err 7404 } 7405 } 7406 7407 if v.Functions != nil { 7408 ok := object.Key("Functions") 7409 if err := awsRestjson1_serializeDocument__listOfFunction(v.Functions, ok); err != nil { 7410 return err 7411 } 7412 } 7413 7414 return nil 7415} 7416 7417func awsRestjson1_serializeDocumentFunctionExecutionConfig(v *types.FunctionExecutionConfig, value smithyjson.Value) error { 7418 object := value.Object() 7419 defer object.Close() 7420 7421 if len(v.IsolationMode) > 0 { 7422 ok := object.Key("IsolationMode") 7423 ok.String(string(v.IsolationMode)) 7424 } 7425 7426 if v.RunAs != nil { 7427 ok := object.Key("RunAs") 7428 if err := awsRestjson1_serializeDocumentFunctionRunAsConfig(v.RunAs, ok); err != nil { 7429 return err 7430 } 7431 } 7432 7433 return nil 7434} 7435 7436func awsRestjson1_serializeDocumentFunctionRunAsConfig(v *types.FunctionRunAsConfig, value smithyjson.Value) error { 7437 object := value.Object() 7438 defer object.Close() 7439 7440 if v.Gid != 0 { 7441 ok := object.Key("Gid") 7442 ok.Integer(v.Gid) 7443 } 7444 7445 if v.Uid != 0 { 7446 ok := object.Key("Uid") 7447 ok.Integer(v.Uid) 7448 } 7449 7450 return nil 7451} 7452 7453func awsRestjson1_serializeDocumentGroupOwnerSetting(v *types.GroupOwnerSetting, value smithyjson.Value) error { 7454 object := value.Object() 7455 defer object.Close() 7456 7457 if v.AutoAddGroupOwner { 7458 ok := object.Key("AutoAddGroupOwner") 7459 ok.Boolean(v.AutoAddGroupOwner) 7460 } 7461 7462 if v.GroupOwner != nil { 7463 ok := object.Key("GroupOwner") 7464 ok.String(*v.GroupOwner) 7465 } 7466 7467 return nil 7468} 7469 7470func awsRestjson1_serializeDocumentGroupVersion(v *types.GroupVersion, value smithyjson.Value) error { 7471 object := value.Object() 7472 defer object.Close() 7473 7474 if v.ConnectorDefinitionVersionArn != nil { 7475 ok := object.Key("ConnectorDefinitionVersionArn") 7476 ok.String(*v.ConnectorDefinitionVersionArn) 7477 } 7478 7479 if v.CoreDefinitionVersionArn != nil { 7480 ok := object.Key("CoreDefinitionVersionArn") 7481 ok.String(*v.CoreDefinitionVersionArn) 7482 } 7483 7484 if v.DeviceDefinitionVersionArn != nil { 7485 ok := object.Key("DeviceDefinitionVersionArn") 7486 ok.String(*v.DeviceDefinitionVersionArn) 7487 } 7488 7489 if v.FunctionDefinitionVersionArn != nil { 7490 ok := object.Key("FunctionDefinitionVersionArn") 7491 ok.String(*v.FunctionDefinitionVersionArn) 7492 } 7493 7494 if v.LoggerDefinitionVersionArn != nil { 7495 ok := object.Key("LoggerDefinitionVersionArn") 7496 ok.String(*v.LoggerDefinitionVersionArn) 7497 } 7498 7499 if v.ResourceDefinitionVersionArn != nil { 7500 ok := object.Key("ResourceDefinitionVersionArn") 7501 ok.String(*v.ResourceDefinitionVersionArn) 7502 } 7503 7504 if v.SubscriptionDefinitionVersionArn != nil { 7505 ok := object.Key("SubscriptionDefinitionVersionArn") 7506 ok.String(*v.SubscriptionDefinitionVersionArn) 7507 } 7508 7509 return nil 7510} 7511 7512func awsRestjson1_serializeDocumentLocalDeviceResourceData(v *types.LocalDeviceResourceData, value smithyjson.Value) error { 7513 object := value.Object() 7514 defer object.Close() 7515 7516 if v.GroupOwnerSetting != nil { 7517 ok := object.Key("GroupOwnerSetting") 7518 if err := awsRestjson1_serializeDocumentGroupOwnerSetting(v.GroupOwnerSetting, ok); err != nil { 7519 return err 7520 } 7521 } 7522 7523 if v.SourcePath != nil { 7524 ok := object.Key("SourcePath") 7525 ok.String(*v.SourcePath) 7526 } 7527 7528 return nil 7529} 7530 7531func awsRestjson1_serializeDocumentLocalVolumeResourceData(v *types.LocalVolumeResourceData, value smithyjson.Value) error { 7532 object := value.Object() 7533 defer object.Close() 7534 7535 if v.DestinationPath != nil { 7536 ok := object.Key("DestinationPath") 7537 ok.String(*v.DestinationPath) 7538 } 7539 7540 if v.GroupOwnerSetting != nil { 7541 ok := object.Key("GroupOwnerSetting") 7542 if err := awsRestjson1_serializeDocumentGroupOwnerSetting(v.GroupOwnerSetting, ok); err != nil { 7543 return err 7544 } 7545 } 7546 7547 if v.SourcePath != nil { 7548 ok := object.Key("SourcePath") 7549 ok.String(*v.SourcePath) 7550 } 7551 7552 return nil 7553} 7554 7555func awsRestjson1_serializeDocumentLogger(v *types.Logger, value smithyjson.Value) error { 7556 object := value.Object() 7557 defer object.Close() 7558 7559 if len(v.Component) > 0 { 7560 ok := object.Key("Component") 7561 ok.String(string(v.Component)) 7562 } 7563 7564 if v.Id != nil { 7565 ok := object.Key("Id") 7566 ok.String(*v.Id) 7567 } 7568 7569 if len(v.Level) > 0 { 7570 ok := object.Key("Level") 7571 ok.String(string(v.Level)) 7572 } 7573 7574 if v.Space != 0 { 7575 ok := object.Key("Space") 7576 ok.Integer(v.Space) 7577 } 7578 7579 if len(v.Type) > 0 { 7580 ok := object.Key("Type") 7581 ok.String(string(v.Type)) 7582 } 7583 7584 return nil 7585} 7586 7587func awsRestjson1_serializeDocumentLoggerDefinitionVersion(v *types.LoggerDefinitionVersion, value smithyjson.Value) error { 7588 object := value.Object() 7589 defer object.Close() 7590 7591 if v.Loggers != nil { 7592 ok := object.Key("Loggers") 7593 if err := awsRestjson1_serializeDocument__listOfLogger(v.Loggers, ok); err != nil { 7594 return err 7595 } 7596 } 7597 7598 return nil 7599} 7600 7601func awsRestjson1_serializeDocumentResource(v *types.Resource, value smithyjson.Value) error { 7602 object := value.Object() 7603 defer object.Close() 7604 7605 if v.Id != nil { 7606 ok := object.Key("Id") 7607 ok.String(*v.Id) 7608 } 7609 7610 if v.Name != nil { 7611 ok := object.Key("Name") 7612 ok.String(*v.Name) 7613 } 7614 7615 if v.ResourceDataContainer != nil { 7616 ok := object.Key("ResourceDataContainer") 7617 if err := awsRestjson1_serializeDocumentResourceDataContainer(v.ResourceDataContainer, ok); err != nil { 7618 return err 7619 } 7620 } 7621 7622 return nil 7623} 7624 7625func awsRestjson1_serializeDocumentResourceAccessPolicy(v *types.ResourceAccessPolicy, value smithyjson.Value) error { 7626 object := value.Object() 7627 defer object.Close() 7628 7629 if len(v.Permission) > 0 { 7630 ok := object.Key("Permission") 7631 ok.String(string(v.Permission)) 7632 } 7633 7634 if v.ResourceId != nil { 7635 ok := object.Key("ResourceId") 7636 ok.String(*v.ResourceId) 7637 } 7638 7639 return nil 7640} 7641 7642func awsRestjson1_serializeDocumentResourceDataContainer(v *types.ResourceDataContainer, value smithyjson.Value) error { 7643 object := value.Object() 7644 defer object.Close() 7645 7646 if v.LocalDeviceResourceData != nil { 7647 ok := object.Key("LocalDeviceResourceData") 7648 if err := awsRestjson1_serializeDocumentLocalDeviceResourceData(v.LocalDeviceResourceData, ok); err != nil { 7649 return err 7650 } 7651 } 7652 7653 if v.LocalVolumeResourceData != nil { 7654 ok := object.Key("LocalVolumeResourceData") 7655 if err := awsRestjson1_serializeDocumentLocalVolumeResourceData(v.LocalVolumeResourceData, ok); err != nil { 7656 return err 7657 } 7658 } 7659 7660 if v.S3MachineLearningModelResourceData != nil { 7661 ok := object.Key("S3MachineLearningModelResourceData") 7662 if err := awsRestjson1_serializeDocumentS3MachineLearningModelResourceData(v.S3MachineLearningModelResourceData, ok); err != nil { 7663 return err 7664 } 7665 } 7666 7667 if v.SageMakerMachineLearningModelResourceData != nil { 7668 ok := object.Key("SageMakerMachineLearningModelResourceData") 7669 if err := awsRestjson1_serializeDocumentSageMakerMachineLearningModelResourceData(v.SageMakerMachineLearningModelResourceData, ok); err != nil { 7670 return err 7671 } 7672 } 7673 7674 if v.SecretsManagerSecretResourceData != nil { 7675 ok := object.Key("SecretsManagerSecretResourceData") 7676 if err := awsRestjson1_serializeDocumentSecretsManagerSecretResourceData(v.SecretsManagerSecretResourceData, ok); err != nil { 7677 return err 7678 } 7679 } 7680 7681 return nil 7682} 7683 7684func awsRestjson1_serializeDocumentResourceDefinitionVersion(v *types.ResourceDefinitionVersion, value smithyjson.Value) error { 7685 object := value.Object() 7686 defer object.Close() 7687 7688 if v.Resources != nil { 7689 ok := object.Key("Resources") 7690 if err := awsRestjson1_serializeDocument__listOfResource(v.Resources, ok); err != nil { 7691 return err 7692 } 7693 } 7694 7695 return nil 7696} 7697 7698func awsRestjson1_serializeDocumentResourceDownloadOwnerSetting(v *types.ResourceDownloadOwnerSetting, value smithyjson.Value) error { 7699 object := value.Object() 7700 defer object.Close() 7701 7702 if v.GroupOwner != nil { 7703 ok := object.Key("GroupOwner") 7704 ok.String(*v.GroupOwner) 7705 } 7706 7707 if len(v.GroupPermission) > 0 { 7708 ok := object.Key("GroupPermission") 7709 ok.String(string(v.GroupPermission)) 7710 } 7711 7712 return nil 7713} 7714 7715func awsRestjson1_serializeDocumentS3MachineLearningModelResourceData(v *types.S3MachineLearningModelResourceData, value smithyjson.Value) error { 7716 object := value.Object() 7717 defer object.Close() 7718 7719 if v.DestinationPath != nil { 7720 ok := object.Key("DestinationPath") 7721 ok.String(*v.DestinationPath) 7722 } 7723 7724 if v.OwnerSetting != nil { 7725 ok := object.Key("OwnerSetting") 7726 if err := awsRestjson1_serializeDocumentResourceDownloadOwnerSetting(v.OwnerSetting, ok); err != nil { 7727 return err 7728 } 7729 } 7730 7731 if v.S3Uri != nil { 7732 ok := object.Key("S3Uri") 7733 ok.String(*v.S3Uri) 7734 } 7735 7736 return nil 7737} 7738 7739func awsRestjson1_serializeDocumentSageMakerMachineLearningModelResourceData(v *types.SageMakerMachineLearningModelResourceData, value smithyjson.Value) error { 7740 object := value.Object() 7741 defer object.Close() 7742 7743 if v.DestinationPath != nil { 7744 ok := object.Key("DestinationPath") 7745 ok.String(*v.DestinationPath) 7746 } 7747 7748 if v.OwnerSetting != nil { 7749 ok := object.Key("OwnerSetting") 7750 if err := awsRestjson1_serializeDocumentResourceDownloadOwnerSetting(v.OwnerSetting, ok); err != nil { 7751 return err 7752 } 7753 } 7754 7755 if v.SageMakerJobArn != nil { 7756 ok := object.Key("SageMakerJobArn") 7757 ok.String(*v.SageMakerJobArn) 7758 } 7759 7760 return nil 7761} 7762 7763func awsRestjson1_serializeDocumentSecretsManagerSecretResourceData(v *types.SecretsManagerSecretResourceData, value smithyjson.Value) error { 7764 object := value.Object() 7765 defer object.Close() 7766 7767 if v.AdditionalStagingLabelsToDownload != nil { 7768 ok := object.Key("AdditionalStagingLabelsToDownload") 7769 if err := awsRestjson1_serializeDocument__listOf__string(v.AdditionalStagingLabelsToDownload, ok); err != nil { 7770 return err 7771 } 7772 } 7773 7774 if v.ARN != nil { 7775 ok := object.Key("ARN") 7776 ok.String(*v.ARN) 7777 } 7778 7779 return nil 7780} 7781 7782func awsRestjson1_serializeDocumentSubscription(v *types.Subscription, value smithyjson.Value) error { 7783 object := value.Object() 7784 defer object.Close() 7785 7786 if v.Id != nil { 7787 ok := object.Key("Id") 7788 ok.String(*v.Id) 7789 } 7790 7791 if v.Source != nil { 7792 ok := object.Key("Source") 7793 ok.String(*v.Source) 7794 } 7795 7796 if v.Subject != nil { 7797 ok := object.Key("Subject") 7798 ok.String(*v.Subject) 7799 } 7800 7801 if v.Target != nil { 7802 ok := object.Key("Target") 7803 ok.String(*v.Target) 7804 } 7805 7806 return nil 7807} 7808 7809func awsRestjson1_serializeDocumentSubscriptionDefinitionVersion(v *types.SubscriptionDefinitionVersion, value smithyjson.Value) error { 7810 object := value.Object() 7811 defer object.Close() 7812 7813 if v.Subscriptions != nil { 7814 ok := object.Key("Subscriptions") 7815 if err := awsRestjson1_serializeDocument__listOfSubscription(v.Subscriptions, ok); err != nil { 7816 return err 7817 } 7818 } 7819 7820 return nil 7821} 7822 7823func awsRestjson1_serializeDocumentTags(v map[string]string, value smithyjson.Value) error { 7824 object := value.Object() 7825 defer object.Close() 7826 7827 for key := range v { 7828 om := object.Key(key) 7829 om.String(v[key]) 7830 } 7831 return nil 7832} 7833 7834func awsRestjson1_serializeDocumentTelemetryConfigurationUpdate(v *types.TelemetryConfigurationUpdate, value smithyjson.Value) error { 7835 object := value.Object() 7836 defer object.Close() 7837 7838 if len(v.Telemetry) > 0 { 7839 ok := object.Key("Telemetry") 7840 ok.String(string(v.Telemetry)) 7841 } 7842 7843 return nil 7844} 7845 7846func awsRestjson1_serializeDocumentUpdateTargets(v []string, value smithyjson.Value) error { 7847 array := value.Array() 7848 defer array.Close() 7849 7850 for i := range v { 7851 av := array.Value() 7852 av.String(v[i]) 7853 } 7854 return nil 7855} 7856