1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package greengrass 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/greengrass/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAssociateRoleToGroup struct { 14} 15 16func (*validateOpAssociateRoleToGroup) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAssociateRoleToGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 21 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 22) { 23 input, ok := in.Parameters.(*AssociateRoleToGroupInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAssociateRoleToGroupInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAssociateServiceRoleToAccount struct { 34} 35 36func (*validateOpAssociateServiceRoleToAccount) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAssociateServiceRoleToAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 41 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 42) { 43 input, ok := in.Parameters.(*AssociateServiceRoleToAccountInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAssociateServiceRoleToAccountInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateConnectorDefinition struct { 54} 55 56func (*validateOpCreateConnectorDefinition) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateConnectorDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 61 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 62) { 63 input, ok := in.Parameters.(*CreateConnectorDefinitionInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateConnectorDefinitionInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateConnectorDefinitionVersion struct { 74} 75 76func (*validateOpCreateConnectorDefinitionVersion) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateConnectorDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 81 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 82) { 83 input, ok := in.Parameters.(*CreateConnectorDefinitionVersionInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateConnectorDefinitionVersionInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateCoreDefinition struct { 94} 95 96func (*validateOpCreateCoreDefinition) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateCoreDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 101 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 102) { 103 input, ok := in.Parameters.(*CreateCoreDefinitionInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateCoreDefinitionInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateCoreDefinitionVersion struct { 114} 115 116func (*validateOpCreateCoreDefinitionVersion) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateCoreDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 121 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 122) { 123 input, ok := in.Parameters.(*CreateCoreDefinitionVersionInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateCoreDefinitionVersionInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateDeployment struct { 134} 135 136func (*validateOpCreateDeployment) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 141 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 142) { 143 input, ok := in.Parameters.(*CreateDeploymentInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateDeploymentInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreateDeviceDefinition struct { 154} 155 156func (*validateOpCreateDeviceDefinition) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreateDeviceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 162) { 163 input, ok := in.Parameters.(*CreateDeviceDefinitionInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreateDeviceDefinitionInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpCreateDeviceDefinitionVersion struct { 174} 175 176func (*validateOpCreateDeviceDefinitionVersion) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpCreateDeviceDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 182) { 183 input, ok := in.Parameters.(*CreateDeviceDefinitionVersionInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpCreateDeviceDefinitionVersionInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpCreateFunctionDefinition struct { 194} 195 196func (*validateOpCreateFunctionDefinition) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpCreateFunctionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 202) { 203 input, ok := in.Parameters.(*CreateFunctionDefinitionInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpCreateFunctionDefinitionInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpCreateFunctionDefinitionVersion struct { 214} 215 216func (*validateOpCreateFunctionDefinitionVersion) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpCreateFunctionDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 222) { 223 input, ok := in.Parameters.(*CreateFunctionDefinitionVersionInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpCreateFunctionDefinitionVersionInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpCreateGroupCertificateAuthority struct { 234} 235 236func (*validateOpCreateGroupCertificateAuthority) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpCreateGroupCertificateAuthority) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 242) { 243 input, ok := in.Parameters.(*CreateGroupCertificateAuthorityInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpCreateGroupCertificateAuthorityInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpCreateGroup struct { 254} 255 256func (*validateOpCreateGroup) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpCreateGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 262) { 263 input, ok := in.Parameters.(*CreateGroupInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpCreateGroupInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpCreateGroupVersion struct { 274} 275 276func (*validateOpCreateGroupVersion) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpCreateGroupVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 282) { 283 input, ok := in.Parameters.(*CreateGroupVersionInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpCreateGroupVersionInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpCreateLoggerDefinition struct { 294} 295 296func (*validateOpCreateLoggerDefinition) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpCreateLoggerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 302) { 303 input, ok := in.Parameters.(*CreateLoggerDefinitionInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpCreateLoggerDefinitionInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpCreateLoggerDefinitionVersion struct { 314} 315 316func (*validateOpCreateLoggerDefinitionVersion) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpCreateLoggerDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 321 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 322) { 323 input, ok := in.Parameters.(*CreateLoggerDefinitionVersionInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpCreateLoggerDefinitionVersionInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpCreateResourceDefinition struct { 334} 335 336func (*validateOpCreateResourceDefinition) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpCreateResourceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 341 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 342) { 343 input, ok := in.Parameters.(*CreateResourceDefinitionInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpCreateResourceDefinitionInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpCreateResourceDefinitionVersion struct { 354} 355 356func (*validateOpCreateResourceDefinitionVersion) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpCreateResourceDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 361 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 362) { 363 input, ok := in.Parameters.(*CreateResourceDefinitionVersionInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpCreateResourceDefinitionVersionInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpCreateSoftwareUpdateJob struct { 374} 375 376func (*validateOpCreateSoftwareUpdateJob) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpCreateSoftwareUpdateJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 381 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 382) { 383 input, ok := in.Parameters.(*CreateSoftwareUpdateJobInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpCreateSoftwareUpdateJobInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpCreateSubscriptionDefinition struct { 394} 395 396func (*validateOpCreateSubscriptionDefinition) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpCreateSubscriptionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 401 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 402) { 403 input, ok := in.Parameters.(*CreateSubscriptionDefinitionInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpCreateSubscriptionDefinitionInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpCreateSubscriptionDefinitionVersion struct { 414} 415 416func (*validateOpCreateSubscriptionDefinitionVersion) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpCreateSubscriptionDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 421 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 422) { 423 input, ok := in.Parameters.(*CreateSubscriptionDefinitionVersionInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpCreateSubscriptionDefinitionVersionInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDeleteConnectorDefinition struct { 434} 435 436func (*validateOpDeleteConnectorDefinition) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDeleteConnectorDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 441 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 442) { 443 input, ok := in.Parameters.(*DeleteConnectorDefinitionInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDeleteConnectorDefinitionInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDeleteCoreDefinition struct { 454} 455 456func (*validateOpDeleteCoreDefinition) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDeleteCoreDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 461 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 462) { 463 input, ok := in.Parameters.(*DeleteCoreDefinitionInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDeleteCoreDefinitionInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpDeleteDeviceDefinition struct { 474} 475 476func (*validateOpDeleteDeviceDefinition) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpDeleteDeviceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 481 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 482) { 483 input, ok := in.Parameters.(*DeleteDeviceDefinitionInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpDeleteDeviceDefinitionInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpDeleteFunctionDefinition struct { 494} 495 496func (*validateOpDeleteFunctionDefinition) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpDeleteFunctionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 501 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 502) { 503 input, ok := in.Parameters.(*DeleteFunctionDefinitionInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpDeleteFunctionDefinitionInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpDeleteGroup struct { 514} 515 516func (*validateOpDeleteGroup) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpDeleteGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 521 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 522) { 523 input, ok := in.Parameters.(*DeleteGroupInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpDeleteGroupInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpDeleteLoggerDefinition struct { 534} 535 536func (*validateOpDeleteLoggerDefinition) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpDeleteLoggerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 541 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 542) { 543 input, ok := in.Parameters.(*DeleteLoggerDefinitionInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpDeleteLoggerDefinitionInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpDeleteResourceDefinition struct { 554} 555 556func (*validateOpDeleteResourceDefinition) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpDeleteResourceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 561 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 562) { 563 input, ok := in.Parameters.(*DeleteResourceDefinitionInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpDeleteResourceDefinitionInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpDeleteSubscriptionDefinition struct { 574} 575 576func (*validateOpDeleteSubscriptionDefinition) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpDeleteSubscriptionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 581 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 582) { 583 input, ok := in.Parameters.(*DeleteSubscriptionDefinitionInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpDeleteSubscriptionDefinitionInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpDisassociateRoleFromGroup struct { 594} 595 596func (*validateOpDisassociateRoleFromGroup) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpDisassociateRoleFromGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 602) { 603 input, ok := in.Parameters.(*DisassociateRoleFromGroupInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpDisassociateRoleFromGroupInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpGetAssociatedRole struct { 614} 615 616func (*validateOpGetAssociatedRole) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpGetAssociatedRole) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 621 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 622) { 623 input, ok := in.Parameters.(*GetAssociatedRoleInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpGetAssociatedRoleInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpGetBulkDeploymentStatus struct { 634} 635 636func (*validateOpGetBulkDeploymentStatus) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpGetBulkDeploymentStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 641 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 642) { 643 input, ok := in.Parameters.(*GetBulkDeploymentStatusInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpGetBulkDeploymentStatusInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpGetConnectivityInfo struct { 654} 655 656func (*validateOpGetConnectivityInfo) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpGetConnectivityInfo) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 661 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 662) { 663 input, ok := in.Parameters.(*GetConnectivityInfoInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpGetConnectivityInfoInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpGetConnectorDefinition struct { 674} 675 676func (*validateOpGetConnectorDefinition) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpGetConnectorDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 681 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 682) { 683 input, ok := in.Parameters.(*GetConnectorDefinitionInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpGetConnectorDefinitionInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpGetConnectorDefinitionVersion struct { 694} 695 696func (*validateOpGetConnectorDefinitionVersion) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpGetConnectorDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 701 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 702) { 703 input, ok := in.Parameters.(*GetConnectorDefinitionVersionInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpGetConnectorDefinitionVersionInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpGetCoreDefinition struct { 714} 715 716func (*validateOpGetCoreDefinition) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpGetCoreDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 721 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 722) { 723 input, ok := in.Parameters.(*GetCoreDefinitionInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpGetCoreDefinitionInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpGetCoreDefinitionVersion struct { 734} 735 736func (*validateOpGetCoreDefinitionVersion) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpGetCoreDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 741 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 742) { 743 input, ok := in.Parameters.(*GetCoreDefinitionVersionInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpGetCoreDefinitionVersionInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpGetDeploymentStatus struct { 754} 755 756func (*validateOpGetDeploymentStatus) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpGetDeploymentStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 761 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 762) { 763 input, ok := in.Parameters.(*GetDeploymentStatusInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpGetDeploymentStatusInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpGetDeviceDefinition struct { 774} 775 776func (*validateOpGetDeviceDefinition) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpGetDeviceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 781 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 782) { 783 input, ok := in.Parameters.(*GetDeviceDefinitionInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpGetDeviceDefinitionInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpGetDeviceDefinitionVersion struct { 794} 795 796func (*validateOpGetDeviceDefinitionVersion) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpGetDeviceDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 802) { 803 input, ok := in.Parameters.(*GetDeviceDefinitionVersionInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpGetDeviceDefinitionVersionInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpGetFunctionDefinition struct { 814} 815 816func (*validateOpGetFunctionDefinition) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpGetFunctionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 821 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 822) { 823 input, ok := in.Parameters.(*GetFunctionDefinitionInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpGetFunctionDefinitionInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpGetFunctionDefinitionVersion struct { 834} 835 836func (*validateOpGetFunctionDefinitionVersion) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpGetFunctionDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 841 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 842) { 843 input, ok := in.Parameters.(*GetFunctionDefinitionVersionInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpGetFunctionDefinitionVersionInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpGetGroupCertificateAuthority struct { 854} 855 856func (*validateOpGetGroupCertificateAuthority) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpGetGroupCertificateAuthority) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 861 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 862) { 863 input, ok := in.Parameters.(*GetGroupCertificateAuthorityInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpGetGroupCertificateAuthorityInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpGetGroupCertificateConfiguration struct { 874} 875 876func (*validateOpGetGroupCertificateConfiguration) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpGetGroupCertificateConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 881 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 882) { 883 input, ok := in.Parameters.(*GetGroupCertificateConfigurationInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpGetGroupCertificateConfigurationInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpGetGroup struct { 894} 895 896func (*validateOpGetGroup) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpGetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 901 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 902) { 903 input, ok := in.Parameters.(*GetGroupInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpGetGroupInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913type validateOpGetGroupVersion struct { 914} 915 916func (*validateOpGetGroupVersion) ID() string { 917 return "OperationInputValidation" 918} 919 920func (m *validateOpGetGroupVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 921 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 922) { 923 input, ok := in.Parameters.(*GetGroupVersionInput) 924 if !ok { 925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 926 } 927 if err := validateOpGetGroupVersionInput(input); err != nil { 928 return out, metadata, err 929 } 930 return next.HandleInitialize(ctx, in) 931} 932 933type validateOpGetLoggerDefinition struct { 934} 935 936func (*validateOpGetLoggerDefinition) ID() string { 937 return "OperationInputValidation" 938} 939 940func (m *validateOpGetLoggerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 941 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 942) { 943 input, ok := in.Parameters.(*GetLoggerDefinitionInput) 944 if !ok { 945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 946 } 947 if err := validateOpGetLoggerDefinitionInput(input); err != nil { 948 return out, metadata, err 949 } 950 return next.HandleInitialize(ctx, in) 951} 952 953type validateOpGetLoggerDefinitionVersion struct { 954} 955 956func (*validateOpGetLoggerDefinitionVersion) ID() string { 957 return "OperationInputValidation" 958} 959 960func (m *validateOpGetLoggerDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 961 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 962) { 963 input, ok := in.Parameters.(*GetLoggerDefinitionVersionInput) 964 if !ok { 965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 966 } 967 if err := validateOpGetLoggerDefinitionVersionInput(input); err != nil { 968 return out, metadata, err 969 } 970 return next.HandleInitialize(ctx, in) 971} 972 973type validateOpGetResourceDefinition struct { 974} 975 976func (*validateOpGetResourceDefinition) ID() string { 977 return "OperationInputValidation" 978} 979 980func (m *validateOpGetResourceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 981 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 982) { 983 input, ok := in.Parameters.(*GetResourceDefinitionInput) 984 if !ok { 985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 986 } 987 if err := validateOpGetResourceDefinitionInput(input); err != nil { 988 return out, metadata, err 989 } 990 return next.HandleInitialize(ctx, in) 991} 992 993type validateOpGetResourceDefinitionVersion struct { 994} 995 996func (*validateOpGetResourceDefinitionVersion) ID() string { 997 return "OperationInputValidation" 998} 999 1000func (m *validateOpGetResourceDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1001 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1002) { 1003 input, ok := in.Parameters.(*GetResourceDefinitionVersionInput) 1004 if !ok { 1005 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1006 } 1007 if err := validateOpGetResourceDefinitionVersionInput(input); err != nil { 1008 return out, metadata, err 1009 } 1010 return next.HandleInitialize(ctx, in) 1011} 1012 1013type validateOpGetSubscriptionDefinition struct { 1014} 1015 1016func (*validateOpGetSubscriptionDefinition) ID() string { 1017 return "OperationInputValidation" 1018} 1019 1020func (m *validateOpGetSubscriptionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1021 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1022) { 1023 input, ok := in.Parameters.(*GetSubscriptionDefinitionInput) 1024 if !ok { 1025 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1026 } 1027 if err := validateOpGetSubscriptionDefinitionInput(input); err != nil { 1028 return out, metadata, err 1029 } 1030 return next.HandleInitialize(ctx, in) 1031} 1032 1033type validateOpGetSubscriptionDefinitionVersion struct { 1034} 1035 1036func (*validateOpGetSubscriptionDefinitionVersion) ID() string { 1037 return "OperationInputValidation" 1038} 1039 1040func (m *validateOpGetSubscriptionDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1041 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1042) { 1043 input, ok := in.Parameters.(*GetSubscriptionDefinitionVersionInput) 1044 if !ok { 1045 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1046 } 1047 if err := validateOpGetSubscriptionDefinitionVersionInput(input); err != nil { 1048 return out, metadata, err 1049 } 1050 return next.HandleInitialize(ctx, in) 1051} 1052 1053type validateOpGetThingRuntimeConfiguration struct { 1054} 1055 1056func (*validateOpGetThingRuntimeConfiguration) ID() string { 1057 return "OperationInputValidation" 1058} 1059 1060func (m *validateOpGetThingRuntimeConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1061 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1062) { 1063 input, ok := in.Parameters.(*GetThingRuntimeConfigurationInput) 1064 if !ok { 1065 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1066 } 1067 if err := validateOpGetThingRuntimeConfigurationInput(input); err != nil { 1068 return out, metadata, err 1069 } 1070 return next.HandleInitialize(ctx, in) 1071} 1072 1073type validateOpListBulkDeploymentDetailedReports struct { 1074} 1075 1076func (*validateOpListBulkDeploymentDetailedReports) ID() string { 1077 return "OperationInputValidation" 1078} 1079 1080func (m *validateOpListBulkDeploymentDetailedReports) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1081 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1082) { 1083 input, ok := in.Parameters.(*ListBulkDeploymentDetailedReportsInput) 1084 if !ok { 1085 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1086 } 1087 if err := validateOpListBulkDeploymentDetailedReportsInput(input); err != nil { 1088 return out, metadata, err 1089 } 1090 return next.HandleInitialize(ctx, in) 1091} 1092 1093type validateOpListConnectorDefinitionVersions struct { 1094} 1095 1096func (*validateOpListConnectorDefinitionVersions) ID() string { 1097 return "OperationInputValidation" 1098} 1099 1100func (m *validateOpListConnectorDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1101 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1102) { 1103 input, ok := in.Parameters.(*ListConnectorDefinitionVersionsInput) 1104 if !ok { 1105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1106 } 1107 if err := validateOpListConnectorDefinitionVersionsInput(input); err != nil { 1108 return out, metadata, err 1109 } 1110 return next.HandleInitialize(ctx, in) 1111} 1112 1113type validateOpListCoreDefinitionVersions struct { 1114} 1115 1116func (*validateOpListCoreDefinitionVersions) ID() string { 1117 return "OperationInputValidation" 1118} 1119 1120func (m *validateOpListCoreDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1121 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1122) { 1123 input, ok := in.Parameters.(*ListCoreDefinitionVersionsInput) 1124 if !ok { 1125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1126 } 1127 if err := validateOpListCoreDefinitionVersionsInput(input); err != nil { 1128 return out, metadata, err 1129 } 1130 return next.HandleInitialize(ctx, in) 1131} 1132 1133type validateOpListDeployments struct { 1134} 1135 1136func (*validateOpListDeployments) ID() string { 1137 return "OperationInputValidation" 1138} 1139 1140func (m *validateOpListDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1141 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1142) { 1143 input, ok := in.Parameters.(*ListDeploymentsInput) 1144 if !ok { 1145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1146 } 1147 if err := validateOpListDeploymentsInput(input); err != nil { 1148 return out, metadata, err 1149 } 1150 return next.HandleInitialize(ctx, in) 1151} 1152 1153type validateOpListDeviceDefinitionVersions struct { 1154} 1155 1156func (*validateOpListDeviceDefinitionVersions) ID() string { 1157 return "OperationInputValidation" 1158} 1159 1160func (m *validateOpListDeviceDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1162) { 1163 input, ok := in.Parameters.(*ListDeviceDefinitionVersionsInput) 1164 if !ok { 1165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1166 } 1167 if err := validateOpListDeviceDefinitionVersionsInput(input); err != nil { 1168 return out, metadata, err 1169 } 1170 return next.HandleInitialize(ctx, in) 1171} 1172 1173type validateOpListFunctionDefinitionVersions struct { 1174} 1175 1176func (*validateOpListFunctionDefinitionVersions) ID() string { 1177 return "OperationInputValidation" 1178} 1179 1180func (m *validateOpListFunctionDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1182) { 1183 input, ok := in.Parameters.(*ListFunctionDefinitionVersionsInput) 1184 if !ok { 1185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1186 } 1187 if err := validateOpListFunctionDefinitionVersionsInput(input); err != nil { 1188 return out, metadata, err 1189 } 1190 return next.HandleInitialize(ctx, in) 1191} 1192 1193type validateOpListGroupCertificateAuthorities struct { 1194} 1195 1196func (*validateOpListGroupCertificateAuthorities) ID() string { 1197 return "OperationInputValidation" 1198} 1199 1200func (m *validateOpListGroupCertificateAuthorities) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1202) { 1203 input, ok := in.Parameters.(*ListGroupCertificateAuthoritiesInput) 1204 if !ok { 1205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1206 } 1207 if err := validateOpListGroupCertificateAuthoritiesInput(input); err != nil { 1208 return out, metadata, err 1209 } 1210 return next.HandleInitialize(ctx, in) 1211} 1212 1213type validateOpListGroupVersions struct { 1214} 1215 1216func (*validateOpListGroupVersions) ID() string { 1217 return "OperationInputValidation" 1218} 1219 1220func (m *validateOpListGroupVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1222) { 1223 input, ok := in.Parameters.(*ListGroupVersionsInput) 1224 if !ok { 1225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1226 } 1227 if err := validateOpListGroupVersionsInput(input); err != nil { 1228 return out, metadata, err 1229 } 1230 return next.HandleInitialize(ctx, in) 1231} 1232 1233type validateOpListLoggerDefinitionVersions struct { 1234} 1235 1236func (*validateOpListLoggerDefinitionVersions) ID() string { 1237 return "OperationInputValidation" 1238} 1239 1240func (m *validateOpListLoggerDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1242) { 1243 input, ok := in.Parameters.(*ListLoggerDefinitionVersionsInput) 1244 if !ok { 1245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1246 } 1247 if err := validateOpListLoggerDefinitionVersionsInput(input); err != nil { 1248 return out, metadata, err 1249 } 1250 return next.HandleInitialize(ctx, in) 1251} 1252 1253type validateOpListResourceDefinitionVersions struct { 1254} 1255 1256func (*validateOpListResourceDefinitionVersions) ID() string { 1257 return "OperationInputValidation" 1258} 1259 1260func (m *validateOpListResourceDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1262) { 1263 input, ok := in.Parameters.(*ListResourceDefinitionVersionsInput) 1264 if !ok { 1265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1266 } 1267 if err := validateOpListResourceDefinitionVersionsInput(input); err != nil { 1268 return out, metadata, err 1269 } 1270 return next.HandleInitialize(ctx, in) 1271} 1272 1273type validateOpListSubscriptionDefinitionVersions struct { 1274} 1275 1276func (*validateOpListSubscriptionDefinitionVersions) ID() string { 1277 return "OperationInputValidation" 1278} 1279 1280func (m *validateOpListSubscriptionDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1282) { 1283 input, ok := in.Parameters.(*ListSubscriptionDefinitionVersionsInput) 1284 if !ok { 1285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1286 } 1287 if err := validateOpListSubscriptionDefinitionVersionsInput(input); err != nil { 1288 return out, metadata, err 1289 } 1290 return next.HandleInitialize(ctx, in) 1291} 1292 1293type validateOpListTagsForResource struct { 1294} 1295 1296func (*validateOpListTagsForResource) ID() string { 1297 return "OperationInputValidation" 1298} 1299 1300func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1302) { 1303 input, ok := in.Parameters.(*ListTagsForResourceInput) 1304 if !ok { 1305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1306 } 1307 if err := validateOpListTagsForResourceInput(input); err != nil { 1308 return out, metadata, err 1309 } 1310 return next.HandleInitialize(ctx, in) 1311} 1312 1313type validateOpResetDeployments struct { 1314} 1315 1316func (*validateOpResetDeployments) ID() string { 1317 return "OperationInputValidation" 1318} 1319 1320func (m *validateOpResetDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1321 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1322) { 1323 input, ok := in.Parameters.(*ResetDeploymentsInput) 1324 if !ok { 1325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1326 } 1327 if err := validateOpResetDeploymentsInput(input); err != nil { 1328 return out, metadata, err 1329 } 1330 return next.HandleInitialize(ctx, in) 1331} 1332 1333type validateOpStartBulkDeployment struct { 1334} 1335 1336func (*validateOpStartBulkDeployment) ID() string { 1337 return "OperationInputValidation" 1338} 1339 1340func (m *validateOpStartBulkDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1341 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1342) { 1343 input, ok := in.Parameters.(*StartBulkDeploymentInput) 1344 if !ok { 1345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1346 } 1347 if err := validateOpStartBulkDeploymentInput(input); err != nil { 1348 return out, metadata, err 1349 } 1350 return next.HandleInitialize(ctx, in) 1351} 1352 1353type validateOpStopBulkDeployment struct { 1354} 1355 1356func (*validateOpStopBulkDeployment) ID() string { 1357 return "OperationInputValidation" 1358} 1359 1360func (m *validateOpStopBulkDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1361 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1362) { 1363 input, ok := in.Parameters.(*StopBulkDeploymentInput) 1364 if !ok { 1365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1366 } 1367 if err := validateOpStopBulkDeploymentInput(input); err != nil { 1368 return out, metadata, err 1369 } 1370 return next.HandleInitialize(ctx, in) 1371} 1372 1373type validateOpTagResource struct { 1374} 1375 1376func (*validateOpTagResource) ID() string { 1377 return "OperationInputValidation" 1378} 1379 1380func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1381 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1382) { 1383 input, ok := in.Parameters.(*TagResourceInput) 1384 if !ok { 1385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1386 } 1387 if err := validateOpTagResourceInput(input); err != nil { 1388 return out, metadata, err 1389 } 1390 return next.HandleInitialize(ctx, in) 1391} 1392 1393type validateOpUntagResource struct { 1394} 1395 1396func (*validateOpUntagResource) ID() string { 1397 return "OperationInputValidation" 1398} 1399 1400func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1401 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1402) { 1403 input, ok := in.Parameters.(*UntagResourceInput) 1404 if !ok { 1405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1406 } 1407 if err := validateOpUntagResourceInput(input); err != nil { 1408 return out, metadata, err 1409 } 1410 return next.HandleInitialize(ctx, in) 1411} 1412 1413type validateOpUpdateConnectivityInfo struct { 1414} 1415 1416func (*validateOpUpdateConnectivityInfo) ID() string { 1417 return "OperationInputValidation" 1418} 1419 1420func (m *validateOpUpdateConnectivityInfo) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1421 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1422) { 1423 input, ok := in.Parameters.(*UpdateConnectivityInfoInput) 1424 if !ok { 1425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1426 } 1427 if err := validateOpUpdateConnectivityInfoInput(input); err != nil { 1428 return out, metadata, err 1429 } 1430 return next.HandleInitialize(ctx, in) 1431} 1432 1433type validateOpUpdateConnectorDefinition struct { 1434} 1435 1436func (*validateOpUpdateConnectorDefinition) ID() string { 1437 return "OperationInputValidation" 1438} 1439 1440func (m *validateOpUpdateConnectorDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1441 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1442) { 1443 input, ok := in.Parameters.(*UpdateConnectorDefinitionInput) 1444 if !ok { 1445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1446 } 1447 if err := validateOpUpdateConnectorDefinitionInput(input); err != nil { 1448 return out, metadata, err 1449 } 1450 return next.HandleInitialize(ctx, in) 1451} 1452 1453type validateOpUpdateCoreDefinition struct { 1454} 1455 1456func (*validateOpUpdateCoreDefinition) ID() string { 1457 return "OperationInputValidation" 1458} 1459 1460func (m *validateOpUpdateCoreDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1461 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1462) { 1463 input, ok := in.Parameters.(*UpdateCoreDefinitionInput) 1464 if !ok { 1465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1466 } 1467 if err := validateOpUpdateCoreDefinitionInput(input); err != nil { 1468 return out, metadata, err 1469 } 1470 return next.HandleInitialize(ctx, in) 1471} 1472 1473type validateOpUpdateDeviceDefinition struct { 1474} 1475 1476func (*validateOpUpdateDeviceDefinition) ID() string { 1477 return "OperationInputValidation" 1478} 1479 1480func (m *validateOpUpdateDeviceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1481 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1482) { 1483 input, ok := in.Parameters.(*UpdateDeviceDefinitionInput) 1484 if !ok { 1485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1486 } 1487 if err := validateOpUpdateDeviceDefinitionInput(input); err != nil { 1488 return out, metadata, err 1489 } 1490 return next.HandleInitialize(ctx, in) 1491} 1492 1493type validateOpUpdateFunctionDefinition struct { 1494} 1495 1496func (*validateOpUpdateFunctionDefinition) ID() string { 1497 return "OperationInputValidation" 1498} 1499 1500func (m *validateOpUpdateFunctionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1501 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1502) { 1503 input, ok := in.Parameters.(*UpdateFunctionDefinitionInput) 1504 if !ok { 1505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1506 } 1507 if err := validateOpUpdateFunctionDefinitionInput(input); err != nil { 1508 return out, metadata, err 1509 } 1510 return next.HandleInitialize(ctx, in) 1511} 1512 1513type validateOpUpdateGroupCertificateConfiguration struct { 1514} 1515 1516func (*validateOpUpdateGroupCertificateConfiguration) ID() string { 1517 return "OperationInputValidation" 1518} 1519 1520func (m *validateOpUpdateGroupCertificateConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1521 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1522) { 1523 input, ok := in.Parameters.(*UpdateGroupCertificateConfigurationInput) 1524 if !ok { 1525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1526 } 1527 if err := validateOpUpdateGroupCertificateConfigurationInput(input); err != nil { 1528 return out, metadata, err 1529 } 1530 return next.HandleInitialize(ctx, in) 1531} 1532 1533type validateOpUpdateGroup struct { 1534} 1535 1536func (*validateOpUpdateGroup) ID() string { 1537 return "OperationInputValidation" 1538} 1539 1540func (m *validateOpUpdateGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1541 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1542) { 1543 input, ok := in.Parameters.(*UpdateGroupInput) 1544 if !ok { 1545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1546 } 1547 if err := validateOpUpdateGroupInput(input); err != nil { 1548 return out, metadata, err 1549 } 1550 return next.HandleInitialize(ctx, in) 1551} 1552 1553type validateOpUpdateLoggerDefinition struct { 1554} 1555 1556func (*validateOpUpdateLoggerDefinition) ID() string { 1557 return "OperationInputValidation" 1558} 1559 1560func (m *validateOpUpdateLoggerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1561 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1562) { 1563 input, ok := in.Parameters.(*UpdateLoggerDefinitionInput) 1564 if !ok { 1565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1566 } 1567 if err := validateOpUpdateLoggerDefinitionInput(input); err != nil { 1568 return out, metadata, err 1569 } 1570 return next.HandleInitialize(ctx, in) 1571} 1572 1573type validateOpUpdateResourceDefinition struct { 1574} 1575 1576func (*validateOpUpdateResourceDefinition) ID() string { 1577 return "OperationInputValidation" 1578} 1579 1580func (m *validateOpUpdateResourceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1581 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1582) { 1583 input, ok := in.Parameters.(*UpdateResourceDefinitionInput) 1584 if !ok { 1585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1586 } 1587 if err := validateOpUpdateResourceDefinitionInput(input); err != nil { 1588 return out, metadata, err 1589 } 1590 return next.HandleInitialize(ctx, in) 1591} 1592 1593type validateOpUpdateSubscriptionDefinition struct { 1594} 1595 1596func (*validateOpUpdateSubscriptionDefinition) ID() string { 1597 return "OperationInputValidation" 1598} 1599 1600func (m *validateOpUpdateSubscriptionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1602) { 1603 input, ok := in.Parameters.(*UpdateSubscriptionDefinitionInput) 1604 if !ok { 1605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1606 } 1607 if err := validateOpUpdateSubscriptionDefinitionInput(input); err != nil { 1608 return out, metadata, err 1609 } 1610 return next.HandleInitialize(ctx, in) 1611} 1612 1613type validateOpUpdateThingRuntimeConfiguration struct { 1614} 1615 1616func (*validateOpUpdateThingRuntimeConfiguration) ID() string { 1617 return "OperationInputValidation" 1618} 1619 1620func (m *validateOpUpdateThingRuntimeConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1621 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1622) { 1623 input, ok := in.Parameters.(*UpdateThingRuntimeConfigurationInput) 1624 if !ok { 1625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1626 } 1627 if err := validateOpUpdateThingRuntimeConfigurationInput(input); err != nil { 1628 return out, metadata, err 1629 } 1630 return next.HandleInitialize(ctx, in) 1631} 1632 1633func addOpAssociateRoleToGroupValidationMiddleware(stack *middleware.Stack) error { 1634 return stack.Initialize.Add(&validateOpAssociateRoleToGroup{}, middleware.After) 1635} 1636 1637func addOpAssociateServiceRoleToAccountValidationMiddleware(stack *middleware.Stack) error { 1638 return stack.Initialize.Add(&validateOpAssociateServiceRoleToAccount{}, middleware.After) 1639} 1640 1641func addOpCreateConnectorDefinitionValidationMiddleware(stack *middleware.Stack) error { 1642 return stack.Initialize.Add(&validateOpCreateConnectorDefinition{}, middleware.After) 1643} 1644 1645func addOpCreateConnectorDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1646 return stack.Initialize.Add(&validateOpCreateConnectorDefinitionVersion{}, middleware.After) 1647} 1648 1649func addOpCreateCoreDefinitionValidationMiddleware(stack *middleware.Stack) error { 1650 return stack.Initialize.Add(&validateOpCreateCoreDefinition{}, middleware.After) 1651} 1652 1653func addOpCreateCoreDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1654 return stack.Initialize.Add(&validateOpCreateCoreDefinitionVersion{}, middleware.After) 1655} 1656 1657func addOpCreateDeploymentValidationMiddleware(stack *middleware.Stack) error { 1658 return stack.Initialize.Add(&validateOpCreateDeployment{}, middleware.After) 1659} 1660 1661func addOpCreateDeviceDefinitionValidationMiddleware(stack *middleware.Stack) error { 1662 return stack.Initialize.Add(&validateOpCreateDeviceDefinition{}, middleware.After) 1663} 1664 1665func addOpCreateDeviceDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1666 return stack.Initialize.Add(&validateOpCreateDeviceDefinitionVersion{}, middleware.After) 1667} 1668 1669func addOpCreateFunctionDefinitionValidationMiddleware(stack *middleware.Stack) error { 1670 return stack.Initialize.Add(&validateOpCreateFunctionDefinition{}, middleware.After) 1671} 1672 1673func addOpCreateFunctionDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1674 return stack.Initialize.Add(&validateOpCreateFunctionDefinitionVersion{}, middleware.After) 1675} 1676 1677func addOpCreateGroupCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error { 1678 return stack.Initialize.Add(&validateOpCreateGroupCertificateAuthority{}, middleware.After) 1679} 1680 1681func addOpCreateGroupValidationMiddleware(stack *middleware.Stack) error { 1682 return stack.Initialize.Add(&validateOpCreateGroup{}, middleware.After) 1683} 1684 1685func addOpCreateGroupVersionValidationMiddleware(stack *middleware.Stack) error { 1686 return stack.Initialize.Add(&validateOpCreateGroupVersion{}, middleware.After) 1687} 1688 1689func addOpCreateLoggerDefinitionValidationMiddleware(stack *middleware.Stack) error { 1690 return stack.Initialize.Add(&validateOpCreateLoggerDefinition{}, middleware.After) 1691} 1692 1693func addOpCreateLoggerDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1694 return stack.Initialize.Add(&validateOpCreateLoggerDefinitionVersion{}, middleware.After) 1695} 1696 1697func addOpCreateResourceDefinitionValidationMiddleware(stack *middleware.Stack) error { 1698 return stack.Initialize.Add(&validateOpCreateResourceDefinition{}, middleware.After) 1699} 1700 1701func addOpCreateResourceDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1702 return stack.Initialize.Add(&validateOpCreateResourceDefinitionVersion{}, middleware.After) 1703} 1704 1705func addOpCreateSoftwareUpdateJobValidationMiddleware(stack *middleware.Stack) error { 1706 return stack.Initialize.Add(&validateOpCreateSoftwareUpdateJob{}, middleware.After) 1707} 1708 1709func addOpCreateSubscriptionDefinitionValidationMiddleware(stack *middleware.Stack) error { 1710 return stack.Initialize.Add(&validateOpCreateSubscriptionDefinition{}, middleware.After) 1711} 1712 1713func addOpCreateSubscriptionDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1714 return stack.Initialize.Add(&validateOpCreateSubscriptionDefinitionVersion{}, middleware.After) 1715} 1716 1717func addOpDeleteConnectorDefinitionValidationMiddleware(stack *middleware.Stack) error { 1718 return stack.Initialize.Add(&validateOpDeleteConnectorDefinition{}, middleware.After) 1719} 1720 1721func addOpDeleteCoreDefinitionValidationMiddleware(stack *middleware.Stack) error { 1722 return stack.Initialize.Add(&validateOpDeleteCoreDefinition{}, middleware.After) 1723} 1724 1725func addOpDeleteDeviceDefinitionValidationMiddleware(stack *middleware.Stack) error { 1726 return stack.Initialize.Add(&validateOpDeleteDeviceDefinition{}, middleware.After) 1727} 1728 1729func addOpDeleteFunctionDefinitionValidationMiddleware(stack *middleware.Stack) error { 1730 return stack.Initialize.Add(&validateOpDeleteFunctionDefinition{}, middleware.After) 1731} 1732 1733func addOpDeleteGroupValidationMiddleware(stack *middleware.Stack) error { 1734 return stack.Initialize.Add(&validateOpDeleteGroup{}, middleware.After) 1735} 1736 1737func addOpDeleteLoggerDefinitionValidationMiddleware(stack *middleware.Stack) error { 1738 return stack.Initialize.Add(&validateOpDeleteLoggerDefinition{}, middleware.After) 1739} 1740 1741func addOpDeleteResourceDefinitionValidationMiddleware(stack *middleware.Stack) error { 1742 return stack.Initialize.Add(&validateOpDeleteResourceDefinition{}, middleware.After) 1743} 1744 1745func addOpDeleteSubscriptionDefinitionValidationMiddleware(stack *middleware.Stack) error { 1746 return stack.Initialize.Add(&validateOpDeleteSubscriptionDefinition{}, middleware.After) 1747} 1748 1749func addOpDisassociateRoleFromGroupValidationMiddleware(stack *middleware.Stack) error { 1750 return stack.Initialize.Add(&validateOpDisassociateRoleFromGroup{}, middleware.After) 1751} 1752 1753func addOpGetAssociatedRoleValidationMiddleware(stack *middleware.Stack) error { 1754 return stack.Initialize.Add(&validateOpGetAssociatedRole{}, middleware.After) 1755} 1756 1757func addOpGetBulkDeploymentStatusValidationMiddleware(stack *middleware.Stack) error { 1758 return stack.Initialize.Add(&validateOpGetBulkDeploymentStatus{}, middleware.After) 1759} 1760 1761func addOpGetConnectivityInfoValidationMiddleware(stack *middleware.Stack) error { 1762 return stack.Initialize.Add(&validateOpGetConnectivityInfo{}, middleware.After) 1763} 1764 1765func addOpGetConnectorDefinitionValidationMiddleware(stack *middleware.Stack) error { 1766 return stack.Initialize.Add(&validateOpGetConnectorDefinition{}, middleware.After) 1767} 1768 1769func addOpGetConnectorDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1770 return stack.Initialize.Add(&validateOpGetConnectorDefinitionVersion{}, middleware.After) 1771} 1772 1773func addOpGetCoreDefinitionValidationMiddleware(stack *middleware.Stack) error { 1774 return stack.Initialize.Add(&validateOpGetCoreDefinition{}, middleware.After) 1775} 1776 1777func addOpGetCoreDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1778 return stack.Initialize.Add(&validateOpGetCoreDefinitionVersion{}, middleware.After) 1779} 1780 1781func addOpGetDeploymentStatusValidationMiddleware(stack *middleware.Stack) error { 1782 return stack.Initialize.Add(&validateOpGetDeploymentStatus{}, middleware.After) 1783} 1784 1785func addOpGetDeviceDefinitionValidationMiddleware(stack *middleware.Stack) error { 1786 return stack.Initialize.Add(&validateOpGetDeviceDefinition{}, middleware.After) 1787} 1788 1789func addOpGetDeviceDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1790 return stack.Initialize.Add(&validateOpGetDeviceDefinitionVersion{}, middleware.After) 1791} 1792 1793func addOpGetFunctionDefinitionValidationMiddleware(stack *middleware.Stack) error { 1794 return stack.Initialize.Add(&validateOpGetFunctionDefinition{}, middleware.After) 1795} 1796 1797func addOpGetFunctionDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1798 return stack.Initialize.Add(&validateOpGetFunctionDefinitionVersion{}, middleware.After) 1799} 1800 1801func addOpGetGroupCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error { 1802 return stack.Initialize.Add(&validateOpGetGroupCertificateAuthority{}, middleware.After) 1803} 1804 1805func addOpGetGroupCertificateConfigurationValidationMiddleware(stack *middleware.Stack) error { 1806 return stack.Initialize.Add(&validateOpGetGroupCertificateConfiguration{}, middleware.After) 1807} 1808 1809func addOpGetGroupValidationMiddleware(stack *middleware.Stack) error { 1810 return stack.Initialize.Add(&validateOpGetGroup{}, middleware.After) 1811} 1812 1813func addOpGetGroupVersionValidationMiddleware(stack *middleware.Stack) error { 1814 return stack.Initialize.Add(&validateOpGetGroupVersion{}, middleware.After) 1815} 1816 1817func addOpGetLoggerDefinitionValidationMiddleware(stack *middleware.Stack) error { 1818 return stack.Initialize.Add(&validateOpGetLoggerDefinition{}, middleware.After) 1819} 1820 1821func addOpGetLoggerDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1822 return stack.Initialize.Add(&validateOpGetLoggerDefinitionVersion{}, middleware.After) 1823} 1824 1825func addOpGetResourceDefinitionValidationMiddleware(stack *middleware.Stack) error { 1826 return stack.Initialize.Add(&validateOpGetResourceDefinition{}, middleware.After) 1827} 1828 1829func addOpGetResourceDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1830 return stack.Initialize.Add(&validateOpGetResourceDefinitionVersion{}, middleware.After) 1831} 1832 1833func addOpGetSubscriptionDefinitionValidationMiddleware(stack *middleware.Stack) error { 1834 return stack.Initialize.Add(&validateOpGetSubscriptionDefinition{}, middleware.After) 1835} 1836 1837func addOpGetSubscriptionDefinitionVersionValidationMiddleware(stack *middleware.Stack) error { 1838 return stack.Initialize.Add(&validateOpGetSubscriptionDefinitionVersion{}, middleware.After) 1839} 1840 1841func addOpGetThingRuntimeConfigurationValidationMiddleware(stack *middleware.Stack) error { 1842 return stack.Initialize.Add(&validateOpGetThingRuntimeConfiguration{}, middleware.After) 1843} 1844 1845func addOpListBulkDeploymentDetailedReportsValidationMiddleware(stack *middleware.Stack) error { 1846 return stack.Initialize.Add(&validateOpListBulkDeploymentDetailedReports{}, middleware.After) 1847} 1848 1849func addOpListConnectorDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error { 1850 return stack.Initialize.Add(&validateOpListConnectorDefinitionVersions{}, middleware.After) 1851} 1852 1853func addOpListCoreDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error { 1854 return stack.Initialize.Add(&validateOpListCoreDefinitionVersions{}, middleware.After) 1855} 1856 1857func addOpListDeploymentsValidationMiddleware(stack *middleware.Stack) error { 1858 return stack.Initialize.Add(&validateOpListDeployments{}, middleware.After) 1859} 1860 1861func addOpListDeviceDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error { 1862 return stack.Initialize.Add(&validateOpListDeviceDefinitionVersions{}, middleware.After) 1863} 1864 1865func addOpListFunctionDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error { 1866 return stack.Initialize.Add(&validateOpListFunctionDefinitionVersions{}, middleware.After) 1867} 1868 1869func addOpListGroupCertificateAuthoritiesValidationMiddleware(stack *middleware.Stack) error { 1870 return stack.Initialize.Add(&validateOpListGroupCertificateAuthorities{}, middleware.After) 1871} 1872 1873func addOpListGroupVersionsValidationMiddleware(stack *middleware.Stack) error { 1874 return stack.Initialize.Add(&validateOpListGroupVersions{}, middleware.After) 1875} 1876 1877func addOpListLoggerDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error { 1878 return stack.Initialize.Add(&validateOpListLoggerDefinitionVersions{}, middleware.After) 1879} 1880 1881func addOpListResourceDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error { 1882 return stack.Initialize.Add(&validateOpListResourceDefinitionVersions{}, middleware.After) 1883} 1884 1885func addOpListSubscriptionDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error { 1886 return stack.Initialize.Add(&validateOpListSubscriptionDefinitionVersions{}, middleware.After) 1887} 1888 1889func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 1890 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 1891} 1892 1893func addOpResetDeploymentsValidationMiddleware(stack *middleware.Stack) error { 1894 return stack.Initialize.Add(&validateOpResetDeployments{}, middleware.After) 1895} 1896 1897func addOpStartBulkDeploymentValidationMiddleware(stack *middleware.Stack) error { 1898 return stack.Initialize.Add(&validateOpStartBulkDeployment{}, middleware.After) 1899} 1900 1901func addOpStopBulkDeploymentValidationMiddleware(stack *middleware.Stack) error { 1902 return stack.Initialize.Add(&validateOpStopBulkDeployment{}, middleware.After) 1903} 1904 1905func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 1906 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 1907} 1908 1909func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 1910 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 1911} 1912 1913func addOpUpdateConnectivityInfoValidationMiddleware(stack *middleware.Stack) error { 1914 return stack.Initialize.Add(&validateOpUpdateConnectivityInfo{}, middleware.After) 1915} 1916 1917func addOpUpdateConnectorDefinitionValidationMiddleware(stack *middleware.Stack) error { 1918 return stack.Initialize.Add(&validateOpUpdateConnectorDefinition{}, middleware.After) 1919} 1920 1921func addOpUpdateCoreDefinitionValidationMiddleware(stack *middleware.Stack) error { 1922 return stack.Initialize.Add(&validateOpUpdateCoreDefinition{}, middleware.After) 1923} 1924 1925func addOpUpdateDeviceDefinitionValidationMiddleware(stack *middleware.Stack) error { 1926 return stack.Initialize.Add(&validateOpUpdateDeviceDefinition{}, middleware.After) 1927} 1928 1929func addOpUpdateFunctionDefinitionValidationMiddleware(stack *middleware.Stack) error { 1930 return stack.Initialize.Add(&validateOpUpdateFunctionDefinition{}, middleware.After) 1931} 1932 1933func addOpUpdateGroupCertificateConfigurationValidationMiddleware(stack *middleware.Stack) error { 1934 return stack.Initialize.Add(&validateOpUpdateGroupCertificateConfiguration{}, middleware.After) 1935} 1936 1937func addOpUpdateGroupValidationMiddleware(stack *middleware.Stack) error { 1938 return stack.Initialize.Add(&validateOpUpdateGroup{}, middleware.After) 1939} 1940 1941func addOpUpdateLoggerDefinitionValidationMiddleware(stack *middleware.Stack) error { 1942 return stack.Initialize.Add(&validateOpUpdateLoggerDefinition{}, middleware.After) 1943} 1944 1945func addOpUpdateResourceDefinitionValidationMiddleware(stack *middleware.Stack) error { 1946 return stack.Initialize.Add(&validateOpUpdateResourceDefinition{}, middleware.After) 1947} 1948 1949func addOpUpdateSubscriptionDefinitionValidationMiddleware(stack *middleware.Stack) error { 1950 return stack.Initialize.Add(&validateOpUpdateSubscriptionDefinition{}, middleware.After) 1951} 1952 1953func addOpUpdateThingRuntimeConfigurationValidationMiddleware(stack *middleware.Stack) error { 1954 return stack.Initialize.Add(&validateOpUpdateThingRuntimeConfiguration{}, middleware.After) 1955} 1956 1957func validate__listOfConnector(v []types.Connector) error { 1958 if v == nil { 1959 return nil 1960 } 1961 invalidParams := smithy.InvalidParamsError{Context: "ListOfConnector"} 1962 for i := range v { 1963 if err := validateConnector(&v[i]); err != nil { 1964 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1965 } 1966 } 1967 if invalidParams.Len() > 0 { 1968 return invalidParams 1969 } else { 1970 return nil 1971 } 1972} 1973 1974func validate__listOfCore(v []types.Core) error { 1975 if v == nil { 1976 return nil 1977 } 1978 invalidParams := smithy.InvalidParamsError{Context: "ListOfCore"} 1979 for i := range v { 1980 if err := validateCore(&v[i]); err != nil { 1981 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1982 } 1983 } 1984 if invalidParams.Len() > 0 { 1985 return invalidParams 1986 } else { 1987 return nil 1988 } 1989} 1990 1991func validate__listOfDevice(v []types.Device) error { 1992 if v == nil { 1993 return nil 1994 } 1995 invalidParams := smithy.InvalidParamsError{Context: "ListOfDevice"} 1996 for i := range v { 1997 if err := validateDevice(&v[i]); err != nil { 1998 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1999 } 2000 } 2001 if invalidParams.Len() > 0 { 2002 return invalidParams 2003 } else { 2004 return nil 2005 } 2006} 2007 2008func validate__listOfFunction(v []types.Function) error { 2009 if v == nil { 2010 return nil 2011 } 2012 invalidParams := smithy.InvalidParamsError{Context: "ListOfFunction"} 2013 for i := range v { 2014 if err := validateFunction(&v[i]); err != nil { 2015 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2016 } 2017 } 2018 if invalidParams.Len() > 0 { 2019 return invalidParams 2020 } else { 2021 return nil 2022 } 2023} 2024 2025func validate__listOfLogger(v []types.Logger) error { 2026 if v == nil { 2027 return nil 2028 } 2029 invalidParams := smithy.InvalidParamsError{Context: "ListOfLogger"} 2030 for i := range v { 2031 if err := validateLogger(&v[i]); err != nil { 2032 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2033 } 2034 } 2035 if invalidParams.Len() > 0 { 2036 return invalidParams 2037 } else { 2038 return nil 2039 } 2040} 2041 2042func validate__listOfResource(v []types.Resource) error { 2043 if v == nil { 2044 return nil 2045 } 2046 invalidParams := smithy.InvalidParamsError{Context: "ListOfResource"} 2047 for i := range v { 2048 if err := validateResource(&v[i]); err != nil { 2049 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2050 } 2051 } 2052 if invalidParams.Len() > 0 { 2053 return invalidParams 2054 } else { 2055 return nil 2056 } 2057} 2058 2059func validate__listOfResourceAccessPolicy(v []types.ResourceAccessPolicy) error { 2060 if v == nil { 2061 return nil 2062 } 2063 invalidParams := smithy.InvalidParamsError{Context: "ListOfResourceAccessPolicy"} 2064 for i := range v { 2065 if err := validateResourceAccessPolicy(&v[i]); err != nil { 2066 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2067 } 2068 } 2069 if invalidParams.Len() > 0 { 2070 return invalidParams 2071 } else { 2072 return nil 2073 } 2074} 2075 2076func validate__listOfSubscription(v []types.Subscription) error { 2077 if v == nil { 2078 return nil 2079 } 2080 invalidParams := smithy.InvalidParamsError{Context: "ListOfSubscription"} 2081 for i := range v { 2082 if err := validateSubscription(&v[i]); err != nil { 2083 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2084 } 2085 } 2086 if invalidParams.Len() > 0 { 2087 return invalidParams 2088 } else { 2089 return nil 2090 } 2091} 2092 2093func validateConnector(v *types.Connector) error { 2094 if v == nil { 2095 return nil 2096 } 2097 invalidParams := smithy.InvalidParamsError{Context: "Connector"} 2098 if v.ConnectorArn == nil { 2099 invalidParams.Add(smithy.NewErrParamRequired("ConnectorArn")) 2100 } 2101 if v.Id == nil { 2102 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2103 } 2104 if invalidParams.Len() > 0 { 2105 return invalidParams 2106 } else { 2107 return nil 2108 } 2109} 2110 2111func validateConnectorDefinitionVersion(v *types.ConnectorDefinitionVersion) error { 2112 if v == nil { 2113 return nil 2114 } 2115 invalidParams := smithy.InvalidParamsError{Context: "ConnectorDefinitionVersion"} 2116 if v.Connectors != nil { 2117 if err := validate__listOfConnector(v.Connectors); err != nil { 2118 invalidParams.AddNested("Connectors", err.(smithy.InvalidParamsError)) 2119 } 2120 } 2121 if invalidParams.Len() > 0 { 2122 return invalidParams 2123 } else { 2124 return nil 2125 } 2126} 2127 2128func validateCore(v *types.Core) error { 2129 if v == nil { 2130 return nil 2131 } 2132 invalidParams := smithy.InvalidParamsError{Context: "Core"} 2133 if v.CertificateArn == nil { 2134 invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) 2135 } 2136 if v.Id == nil { 2137 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2138 } 2139 if v.ThingArn == nil { 2140 invalidParams.Add(smithy.NewErrParamRequired("ThingArn")) 2141 } 2142 if invalidParams.Len() > 0 { 2143 return invalidParams 2144 } else { 2145 return nil 2146 } 2147} 2148 2149func validateCoreDefinitionVersion(v *types.CoreDefinitionVersion) error { 2150 if v == nil { 2151 return nil 2152 } 2153 invalidParams := smithy.InvalidParamsError{Context: "CoreDefinitionVersion"} 2154 if v.Cores != nil { 2155 if err := validate__listOfCore(v.Cores); err != nil { 2156 invalidParams.AddNested("Cores", err.(smithy.InvalidParamsError)) 2157 } 2158 } 2159 if invalidParams.Len() > 0 { 2160 return invalidParams 2161 } else { 2162 return nil 2163 } 2164} 2165 2166func validateDevice(v *types.Device) error { 2167 if v == nil { 2168 return nil 2169 } 2170 invalidParams := smithy.InvalidParamsError{Context: "Device"} 2171 if v.CertificateArn == nil { 2172 invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) 2173 } 2174 if v.Id == nil { 2175 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2176 } 2177 if v.ThingArn == nil { 2178 invalidParams.Add(smithy.NewErrParamRequired("ThingArn")) 2179 } 2180 if invalidParams.Len() > 0 { 2181 return invalidParams 2182 } else { 2183 return nil 2184 } 2185} 2186 2187func validateDeviceDefinitionVersion(v *types.DeviceDefinitionVersion) error { 2188 if v == nil { 2189 return nil 2190 } 2191 invalidParams := smithy.InvalidParamsError{Context: "DeviceDefinitionVersion"} 2192 if v.Devices != nil { 2193 if err := validate__listOfDevice(v.Devices); err != nil { 2194 invalidParams.AddNested("Devices", err.(smithy.InvalidParamsError)) 2195 } 2196 } 2197 if invalidParams.Len() > 0 { 2198 return invalidParams 2199 } else { 2200 return nil 2201 } 2202} 2203 2204func validateFunction(v *types.Function) error { 2205 if v == nil { 2206 return nil 2207 } 2208 invalidParams := smithy.InvalidParamsError{Context: "Function"} 2209 if v.FunctionConfiguration != nil { 2210 if err := validateFunctionConfiguration(v.FunctionConfiguration); err != nil { 2211 invalidParams.AddNested("FunctionConfiguration", err.(smithy.InvalidParamsError)) 2212 } 2213 } 2214 if v.Id == nil { 2215 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2216 } 2217 if invalidParams.Len() > 0 { 2218 return invalidParams 2219 } else { 2220 return nil 2221 } 2222} 2223 2224func validateFunctionConfiguration(v *types.FunctionConfiguration) error { 2225 if v == nil { 2226 return nil 2227 } 2228 invalidParams := smithy.InvalidParamsError{Context: "FunctionConfiguration"} 2229 if v.Environment != nil { 2230 if err := validateFunctionConfigurationEnvironment(v.Environment); err != nil { 2231 invalidParams.AddNested("Environment", err.(smithy.InvalidParamsError)) 2232 } 2233 } 2234 if invalidParams.Len() > 0 { 2235 return invalidParams 2236 } else { 2237 return nil 2238 } 2239} 2240 2241func validateFunctionConfigurationEnvironment(v *types.FunctionConfigurationEnvironment) error { 2242 if v == nil { 2243 return nil 2244 } 2245 invalidParams := smithy.InvalidParamsError{Context: "FunctionConfigurationEnvironment"} 2246 if v.ResourceAccessPolicies != nil { 2247 if err := validate__listOfResourceAccessPolicy(v.ResourceAccessPolicies); err != nil { 2248 invalidParams.AddNested("ResourceAccessPolicies", err.(smithy.InvalidParamsError)) 2249 } 2250 } 2251 if invalidParams.Len() > 0 { 2252 return invalidParams 2253 } else { 2254 return nil 2255 } 2256} 2257 2258func validateFunctionDefinitionVersion(v *types.FunctionDefinitionVersion) error { 2259 if v == nil { 2260 return nil 2261 } 2262 invalidParams := smithy.InvalidParamsError{Context: "FunctionDefinitionVersion"} 2263 if v.Functions != nil { 2264 if err := validate__listOfFunction(v.Functions); err != nil { 2265 invalidParams.AddNested("Functions", err.(smithy.InvalidParamsError)) 2266 } 2267 } 2268 if invalidParams.Len() > 0 { 2269 return invalidParams 2270 } else { 2271 return nil 2272 } 2273} 2274 2275func validateLogger(v *types.Logger) error { 2276 if v == nil { 2277 return nil 2278 } 2279 invalidParams := smithy.InvalidParamsError{Context: "Logger"} 2280 if len(v.Component) == 0 { 2281 invalidParams.Add(smithy.NewErrParamRequired("Component")) 2282 } 2283 if v.Id == nil { 2284 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2285 } 2286 if len(v.Level) == 0 { 2287 invalidParams.Add(smithy.NewErrParamRequired("Level")) 2288 } 2289 if len(v.Type) == 0 { 2290 invalidParams.Add(smithy.NewErrParamRequired("Type")) 2291 } 2292 if invalidParams.Len() > 0 { 2293 return invalidParams 2294 } else { 2295 return nil 2296 } 2297} 2298 2299func validateLoggerDefinitionVersion(v *types.LoggerDefinitionVersion) error { 2300 if v == nil { 2301 return nil 2302 } 2303 invalidParams := smithy.InvalidParamsError{Context: "LoggerDefinitionVersion"} 2304 if v.Loggers != nil { 2305 if err := validate__listOfLogger(v.Loggers); err != nil { 2306 invalidParams.AddNested("Loggers", err.(smithy.InvalidParamsError)) 2307 } 2308 } 2309 if invalidParams.Len() > 0 { 2310 return invalidParams 2311 } else { 2312 return nil 2313 } 2314} 2315 2316func validateResource(v *types.Resource) error { 2317 if v == nil { 2318 return nil 2319 } 2320 invalidParams := smithy.InvalidParamsError{Context: "Resource"} 2321 if v.Id == nil { 2322 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2323 } 2324 if v.Name == nil { 2325 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2326 } 2327 if v.ResourceDataContainer == nil { 2328 invalidParams.Add(smithy.NewErrParamRequired("ResourceDataContainer")) 2329 } else if v.ResourceDataContainer != nil { 2330 if err := validateResourceDataContainer(v.ResourceDataContainer); err != nil { 2331 invalidParams.AddNested("ResourceDataContainer", err.(smithy.InvalidParamsError)) 2332 } 2333 } 2334 if invalidParams.Len() > 0 { 2335 return invalidParams 2336 } else { 2337 return nil 2338 } 2339} 2340 2341func validateResourceAccessPolicy(v *types.ResourceAccessPolicy) error { 2342 if v == nil { 2343 return nil 2344 } 2345 invalidParams := smithy.InvalidParamsError{Context: "ResourceAccessPolicy"} 2346 if v.ResourceId == nil { 2347 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 2348 } 2349 if invalidParams.Len() > 0 { 2350 return invalidParams 2351 } else { 2352 return nil 2353 } 2354} 2355 2356func validateResourceDataContainer(v *types.ResourceDataContainer) error { 2357 if v == nil { 2358 return nil 2359 } 2360 invalidParams := smithy.InvalidParamsError{Context: "ResourceDataContainer"} 2361 if v.S3MachineLearningModelResourceData != nil { 2362 if err := validateS3MachineLearningModelResourceData(v.S3MachineLearningModelResourceData); err != nil { 2363 invalidParams.AddNested("S3MachineLearningModelResourceData", err.(smithy.InvalidParamsError)) 2364 } 2365 } 2366 if v.SageMakerMachineLearningModelResourceData != nil { 2367 if err := validateSageMakerMachineLearningModelResourceData(v.SageMakerMachineLearningModelResourceData); err != nil { 2368 invalidParams.AddNested("SageMakerMachineLearningModelResourceData", err.(smithy.InvalidParamsError)) 2369 } 2370 } 2371 if invalidParams.Len() > 0 { 2372 return invalidParams 2373 } else { 2374 return nil 2375 } 2376} 2377 2378func validateResourceDefinitionVersion(v *types.ResourceDefinitionVersion) error { 2379 if v == nil { 2380 return nil 2381 } 2382 invalidParams := smithy.InvalidParamsError{Context: "ResourceDefinitionVersion"} 2383 if v.Resources != nil { 2384 if err := validate__listOfResource(v.Resources); err != nil { 2385 invalidParams.AddNested("Resources", err.(smithy.InvalidParamsError)) 2386 } 2387 } 2388 if invalidParams.Len() > 0 { 2389 return invalidParams 2390 } else { 2391 return nil 2392 } 2393} 2394 2395func validateResourceDownloadOwnerSetting(v *types.ResourceDownloadOwnerSetting) error { 2396 if v == nil { 2397 return nil 2398 } 2399 invalidParams := smithy.InvalidParamsError{Context: "ResourceDownloadOwnerSetting"} 2400 if v.GroupOwner == nil { 2401 invalidParams.Add(smithy.NewErrParamRequired("GroupOwner")) 2402 } 2403 if len(v.GroupPermission) == 0 { 2404 invalidParams.Add(smithy.NewErrParamRequired("GroupPermission")) 2405 } 2406 if invalidParams.Len() > 0 { 2407 return invalidParams 2408 } else { 2409 return nil 2410 } 2411} 2412 2413func validateS3MachineLearningModelResourceData(v *types.S3MachineLearningModelResourceData) error { 2414 if v == nil { 2415 return nil 2416 } 2417 invalidParams := smithy.InvalidParamsError{Context: "S3MachineLearningModelResourceData"} 2418 if v.OwnerSetting != nil { 2419 if err := validateResourceDownloadOwnerSetting(v.OwnerSetting); err != nil { 2420 invalidParams.AddNested("OwnerSetting", err.(smithy.InvalidParamsError)) 2421 } 2422 } 2423 if invalidParams.Len() > 0 { 2424 return invalidParams 2425 } else { 2426 return nil 2427 } 2428} 2429 2430func validateSageMakerMachineLearningModelResourceData(v *types.SageMakerMachineLearningModelResourceData) error { 2431 if v == nil { 2432 return nil 2433 } 2434 invalidParams := smithy.InvalidParamsError{Context: "SageMakerMachineLearningModelResourceData"} 2435 if v.OwnerSetting != nil { 2436 if err := validateResourceDownloadOwnerSetting(v.OwnerSetting); err != nil { 2437 invalidParams.AddNested("OwnerSetting", err.(smithy.InvalidParamsError)) 2438 } 2439 } 2440 if invalidParams.Len() > 0 { 2441 return invalidParams 2442 } else { 2443 return nil 2444 } 2445} 2446 2447func validateSubscription(v *types.Subscription) error { 2448 if v == nil { 2449 return nil 2450 } 2451 invalidParams := smithy.InvalidParamsError{Context: "Subscription"} 2452 if v.Id == nil { 2453 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2454 } 2455 if v.Source == nil { 2456 invalidParams.Add(smithy.NewErrParamRequired("Source")) 2457 } 2458 if v.Subject == nil { 2459 invalidParams.Add(smithy.NewErrParamRequired("Subject")) 2460 } 2461 if v.Target == nil { 2462 invalidParams.Add(smithy.NewErrParamRequired("Target")) 2463 } 2464 if invalidParams.Len() > 0 { 2465 return invalidParams 2466 } else { 2467 return nil 2468 } 2469} 2470 2471func validateSubscriptionDefinitionVersion(v *types.SubscriptionDefinitionVersion) error { 2472 if v == nil { 2473 return nil 2474 } 2475 invalidParams := smithy.InvalidParamsError{Context: "SubscriptionDefinitionVersion"} 2476 if v.Subscriptions != nil { 2477 if err := validate__listOfSubscription(v.Subscriptions); err != nil { 2478 invalidParams.AddNested("Subscriptions", err.(smithy.InvalidParamsError)) 2479 } 2480 } 2481 if invalidParams.Len() > 0 { 2482 return invalidParams 2483 } else { 2484 return nil 2485 } 2486} 2487 2488func validateTelemetryConfigurationUpdate(v *types.TelemetryConfigurationUpdate) error { 2489 if v == nil { 2490 return nil 2491 } 2492 invalidParams := smithy.InvalidParamsError{Context: "TelemetryConfigurationUpdate"} 2493 if len(v.Telemetry) == 0 { 2494 invalidParams.Add(smithy.NewErrParamRequired("Telemetry")) 2495 } 2496 if invalidParams.Len() > 0 { 2497 return invalidParams 2498 } else { 2499 return nil 2500 } 2501} 2502 2503func validateOpAssociateRoleToGroupInput(v *AssociateRoleToGroupInput) error { 2504 if v == nil { 2505 return nil 2506 } 2507 invalidParams := smithy.InvalidParamsError{Context: "AssociateRoleToGroupInput"} 2508 if v.GroupId == nil { 2509 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 2510 } 2511 if v.RoleArn == nil { 2512 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 2513 } 2514 if invalidParams.Len() > 0 { 2515 return invalidParams 2516 } else { 2517 return nil 2518 } 2519} 2520 2521func validateOpAssociateServiceRoleToAccountInput(v *AssociateServiceRoleToAccountInput) error { 2522 if v == nil { 2523 return nil 2524 } 2525 invalidParams := smithy.InvalidParamsError{Context: "AssociateServiceRoleToAccountInput"} 2526 if v.RoleArn == nil { 2527 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 2528 } 2529 if invalidParams.Len() > 0 { 2530 return invalidParams 2531 } else { 2532 return nil 2533 } 2534} 2535 2536func validateOpCreateConnectorDefinitionInput(v *CreateConnectorDefinitionInput) error { 2537 if v == nil { 2538 return nil 2539 } 2540 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectorDefinitionInput"} 2541 if v.InitialVersion != nil { 2542 if err := validateConnectorDefinitionVersion(v.InitialVersion); err != nil { 2543 invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError)) 2544 } 2545 } 2546 if invalidParams.Len() > 0 { 2547 return invalidParams 2548 } else { 2549 return nil 2550 } 2551} 2552 2553func validateOpCreateConnectorDefinitionVersionInput(v *CreateConnectorDefinitionVersionInput) error { 2554 if v == nil { 2555 return nil 2556 } 2557 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectorDefinitionVersionInput"} 2558 if v.ConnectorDefinitionId == nil { 2559 invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId")) 2560 } 2561 if v.Connectors != nil { 2562 if err := validate__listOfConnector(v.Connectors); err != nil { 2563 invalidParams.AddNested("Connectors", err.(smithy.InvalidParamsError)) 2564 } 2565 } 2566 if invalidParams.Len() > 0 { 2567 return invalidParams 2568 } else { 2569 return nil 2570 } 2571} 2572 2573func validateOpCreateCoreDefinitionInput(v *CreateCoreDefinitionInput) error { 2574 if v == nil { 2575 return nil 2576 } 2577 invalidParams := smithy.InvalidParamsError{Context: "CreateCoreDefinitionInput"} 2578 if v.InitialVersion != nil { 2579 if err := validateCoreDefinitionVersion(v.InitialVersion); err != nil { 2580 invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError)) 2581 } 2582 } 2583 if invalidParams.Len() > 0 { 2584 return invalidParams 2585 } else { 2586 return nil 2587 } 2588} 2589 2590func validateOpCreateCoreDefinitionVersionInput(v *CreateCoreDefinitionVersionInput) error { 2591 if v == nil { 2592 return nil 2593 } 2594 invalidParams := smithy.InvalidParamsError{Context: "CreateCoreDefinitionVersionInput"} 2595 if v.CoreDefinitionId == nil { 2596 invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId")) 2597 } 2598 if v.Cores != nil { 2599 if err := validate__listOfCore(v.Cores); err != nil { 2600 invalidParams.AddNested("Cores", err.(smithy.InvalidParamsError)) 2601 } 2602 } 2603 if invalidParams.Len() > 0 { 2604 return invalidParams 2605 } else { 2606 return nil 2607 } 2608} 2609 2610func validateOpCreateDeploymentInput(v *CreateDeploymentInput) error { 2611 if v == nil { 2612 return nil 2613 } 2614 invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentInput"} 2615 if len(v.DeploymentType) == 0 { 2616 invalidParams.Add(smithy.NewErrParamRequired("DeploymentType")) 2617 } 2618 if v.GroupId == nil { 2619 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 2620 } 2621 if invalidParams.Len() > 0 { 2622 return invalidParams 2623 } else { 2624 return nil 2625 } 2626} 2627 2628func validateOpCreateDeviceDefinitionInput(v *CreateDeviceDefinitionInput) error { 2629 if v == nil { 2630 return nil 2631 } 2632 invalidParams := smithy.InvalidParamsError{Context: "CreateDeviceDefinitionInput"} 2633 if v.InitialVersion != nil { 2634 if err := validateDeviceDefinitionVersion(v.InitialVersion); err != nil { 2635 invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError)) 2636 } 2637 } 2638 if invalidParams.Len() > 0 { 2639 return invalidParams 2640 } else { 2641 return nil 2642 } 2643} 2644 2645func validateOpCreateDeviceDefinitionVersionInput(v *CreateDeviceDefinitionVersionInput) error { 2646 if v == nil { 2647 return nil 2648 } 2649 invalidParams := smithy.InvalidParamsError{Context: "CreateDeviceDefinitionVersionInput"} 2650 if v.DeviceDefinitionId == nil { 2651 invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId")) 2652 } 2653 if v.Devices != nil { 2654 if err := validate__listOfDevice(v.Devices); err != nil { 2655 invalidParams.AddNested("Devices", err.(smithy.InvalidParamsError)) 2656 } 2657 } 2658 if invalidParams.Len() > 0 { 2659 return invalidParams 2660 } else { 2661 return nil 2662 } 2663} 2664 2665func validateOpCreateFunctionDefinitionInput(v *CreateFunctionDefinitionInput) error { 2666 if v == nil { 2667 return nil 2668 } 2669 invalidParams := smithy.InvalidParamsError{Context: "CreateFunctionDefinitionInput"} 2670 if v.InitialVersion != nil { 2671 if err := validateFunctionDefinitionVersion(v.InitialVersion); err != nil { 2672 invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError)) 2673 } 2674 } 2675 if invalidParams.Len() > 0 { 2676 return invalidParams 2677 } else { 2678 return nil 2679 } 2680} 2681 2682func validateOpCreateFunctionDefinitionVersionInput(v *CreateFunctionDefinitionVersionInput) error { 2683 if v == nil { 2684 return nil 2685 } 2686 invalidParams := smithy.InvalidParamsError{Context: "CreateFunctionDefinitionVersionInput"} 2687 if v.FunctionDefinitionId == nil { 2688 invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId")) 2689 } 2690 if v.Functions != nil { 2691 if err := validate__listOfFunction(v.Functions); err != nil { 2692 invalidParams.AddNested("Functions", err.(smithy.InvalidParamsError)) 2693 } 2694 } 2695 if invalidParams.Len() > 0 { 2696 return invalidParams 2697 } else { 2698 return nil 2699 } 2700} 2701 2702func validateOpCreateGroupCertificateAuthorityInput(v *CreateGroupCertificateAuthorityInput) error { 2703 if v == nil { 2704 return nil 2705 } 2706 invalidParams := smithy.InvalidParamsError{Context: "CreateGroupCertificateAuthorityInput"} 2707 if v.GroupId == nil { 2708 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 2709 } 2710 if invalidParams.Len() > 0 { 2711 return invalidParams 2712 } else { 2713 return nil 2714 } 2715} 2716 2717func validateOpCreateGroupInput(v *CreateGroupInput) error { 2718 if v == nil { 2719 return nil 2720 } 2721 invalidParams := smithy.InvalidParamsError{Context: "CreateGroupInput"} 2722 if v.Name == nil { 2723 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2724 } 2725 if invalidParams.Len() > 0 { 2726 return invalidParams 2727 } else { 2728 return nil 2729 } 2730} 2731 2732func validateOpCreateGroupVersionInput(v *CreateGroupVersionInput) error { 2733 if v == nil { 2734 return nil 2735 } 2736 invalidParams := smithy.InvalidParamsError{Context: "CreateGroupVersionInput"} 2737 if v.GroupId == nil { 2738 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 2739 } 2740 if invalidParams.Len() > 0 { 2741 return invalidParams 2742 } else { 2743 return nil 2744 } 2745} 2746 2747func validateOpCreateLoggerDefinitionInput(v *CreateLoggerDefinitionInput) error { 2748 if v == nil { 2749 return nil 2750 } 2751 invalidParams := smithy.InvalidParamsError{Context: "CreateLoggerDefinitionInput"} 2752 if v.InitialVersion != nil { 2753 if err := validateLoggerDefinitionVersion(v.InitialVersion); err != nil { 2754 invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError)) 2755 } 2756 } 2757 if invalidParams.Len() > 0 { 2758 return invalidParams 2759 } else { 2760 return nil 2761 } 2762} 2763 2764func validateOpCreateLoggerDefinitionVersionInput(v *CreateLoggerDefinitionVersionInput) error { 2765 if v == nil { 2766 return nil 2767 } 2768 invalidParams := smithy.InvalidParamsError{Context: "CreateLoggerDefinitionVersionInput"} 2769 if v.LoggerDefinitionId == nil { 2770 invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId")) 2771 } 2772 if v.Loggers != nil { 2773 if err := validate__listOfLogger(v.Loggers); err != nil { 2774 invalidParams.AddNested("Loggers", err.(smithy.InvalidParamsError)) 2775 } 2776 } 2777 if invalidParams.Len() > 0 { 2778 return invalidParams 2779 } else { 2780 return nil 2781 } 2782} 2783 2784func validateOpCreateResourceDefinitionInput(v *CreateResourceDefinitionInput) error { 2785 if v == nil { 2786 return nil 2787 } 2788 invalidParams := smithy.InvalidParamsError{Context: "CreateResourceDefinitionInput"} 2789 if v.InitialVersion != nil { 2790 if err := validateResourceDefinitionVersion(v.InitialVersion); err != nil { 2791 invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError)) 2792 } 2793 } 2794 if invalidParams.Len() > 0 { 2795 return invalidParams 2796 } else { 2797 return nil 2798 } 2799} 2800 2801func validateOpCreateResourceDefinitionVersionInput(v *CreateResourceDefinitionVersionInput) error { 2802 if v == nil { 2803 return nil 2804 } 2805 invalidParams := smithy.InvalidParamsError{Context: "CreateResourceDefinitionVersionInput"} 2806 if v.ResourceDefinitionId == nil { 2807 invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId")) 2808 } 2809 if v.Resources != nil { 2810 if err := validate__listOfResource(v.Resources); err != nil { 2811 invalidParams.AddNested("Resources", err.(smithy.InvalidParamsError)) 2812 } 2813 } 2814 if invalidParams.Len() > 0 { 2815 return invalidParams 2816 } else { 2817 return nil 2818 } 2819} 2820 2821func validateOpCreateSoftwareUpdateJobInput(v *CreateSoftwareUpdateJobInput) error { 2822 if v == nil { 2823 return nil 2824 } 2825 invalidParams := smithy.InvalidParamsError{Context: "CreateSoftwareUpdateJobInput"} 2826 if v.S3UrlSignerRole == nil { 2827 invalidParams.Add(smithy.NewErrParamRequired("S3UrlSignerRole")) 2828 } 2829 if len(v.SoftwareToUpdate) == 0 { 2830 invalidParams.Add(smithy.NewErrParamRequired("SoftwareToUpdate")) 2831 } 2832 if v.UpdateTargets == nil { 2833 invalidParams.Add(smithy.NewErrParamRequired("UpdateTargets")) 2834 } 2835 if len(v.UpdateTargetsArchitecture) == 0 { 2836 invalidParams.Add(smithy.NewErrParamRequired("UpdateTargetsArchitecture")) 2837 } 2838 if len(v.UpdateTargetsOperatingSystem) == 0 { 2839 invalidParams.Add(smithy.NewErrParamRequired("UpdateTargetsOperatingSystem")) 2840 } 2841 if invalidParams.Len() > 0 { 2842 return invalidParams 2843 } else { 2844 return nil 2845 } 2846} 2847 2848func validateOpCreateSubscriptionDefinitionInput(v *CreateSubscriptionDefinitionInput) error { 2849 if v == nil { 2850 return nil 2851 } 2852 invalidParams := smithy.InvalidParamsError{Context: "CreateSubscriptionDefinitionInput"} 2853 if v.InitialVersion != nil { 2854 if err := validateSubscriptionDefinitionVersion(v.InitialVersion); err != nil { 2855 invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError)) 2856 } 2857 } 2858 if invalidParams.Len() > 0 { 2859 return invalidParams 2860 } else { 2861 return nil 2862 } 2863} 2864 2865func validateOpCreateSubscriptionDefinitionVersionInput(v *CreateSubscriptionDefinitionVersionInput) error { 2866 if v == nil { 2867 return nil 2868 } 2869 invalidParams := smithy.InvalidParamsError{Context: "CreateSubscriptionDefinitionVersionInput"} 2870 if v.SubscriptionDefinitionId == nil { 2871 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId")) 2872 } 2873 if v.Subscriptions != nil { 2874 if err := validate__listOfSubscription(v.Subscriptions); err != nil { 2875 invalidParams.AddNested("Subscriptions", err.(smithy.InvalidParamsError)) 2876 } 2877 } 2878 if invalidParams.Len() > 0 { 2879 return invalidParams 2880 } else { 2881 return nil 2882 } 2883} 2884 2885func validateOpDeleteConnectorDefinitionInput(v *DeleteConnectorDefinitionInput) error { 2886 if v == nil { 2887 return nil 2888 } 2889 invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectorDefinitionInput"} 2890 if v.ConnectorDefinitionId == nil { 2891 invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId")) 2892 } 2893 if invalidParams.Len() > 0 { 2894 return invalidParams 2895 } else { 2896 return nil 2897 } 2898} 2899 2900func validateOpDeleteCoreDefinitionInput(v *DeleteCoreDefinitionInput) error { 2901 if v == nil { 2902 return nil 2903 } 2904 invalidParams := smithy.InvalidParamsError{Context: "DeleteCoreDefinitionInput"} 2905 if v.CoreDefinitionId == nil { 2906 invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId")) 2907 } 2908 if invalidParams.Len() > 0 { 2909 return invalidParams 2910 } else { 2911 return nil 2912 } 2913} 2914 2915func validateOpDeleteDeviceDefinitionInput(v *DeleteDeviceDefinitionInput) error { 2916 if v == nil { 2917 return nil 2918 } 2919 invalidParams := smithy.InvalidParamsError{Context: "DeleteDeviceDefinitionInput"} 2920 if v.DeviceDefinitionId == nil { 2921 invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId")) 2922 } 2923 if invalidParams.Len() > 0 { 2924 return invalidParams 2925 } else { 2926 return nil 2927 } 2928} 2929 2930func validateOpDeleteFunctionDefinitionInput(v *DeleteFunctionDefinitionInput) error { 2931 if v == nil { 2932 return nil 2933 } 2934 invalidParams := smithy.InvalidParamsError{Context: "DeleteFunctionDefinitionInput"} 2935 if v.FunctionDefinitionId == nil { 2936 invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId")) 2937 } 2938 if invalidParams.Len() > 0 { 2939 return invalidParams 2940 } else { 2941 return nil 2942 } 2943} 2944 2945func validateOpDeleteGroupInput(v *DeleteGroupInput) error { 2946 if v == nil { 2947 return nil 2948 } 2949 invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupInput"} 2950 if v.GroupId == nil { 2951 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 2952 } 2953 if invalidParams.Len() > 0 { 2954 return invalidParams 2955 } else { 2956 return nil 2957 } 2958} 2959 2960func validateOpDeleteLoggerDefinitionInput(v *DeleteLoggerDefinitionInput) error { 2961 if v == nil { 2962 return nil 2963 } 2964 invalidParams := smithy.InvalidParamsError{Context: "DeleteLoggerDefinitionInput"} 2965 if v.LoggerDefinitionId == nil { 2966 invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId")) 2967 } 2968 if invalidParams.Len() > 0 { 2969 return invalidParams 2970 } else { 2971 return nil 2972 } 2973} 2974 2975func validateOpDeleteResourceDefinitionInput(v *DeleteResourceDefinitionInput) error { 2976 if v == nil { 2977 return nil 2978 } 2979 invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceDefinitionInput"} 2980 if v.ResourceDefinitionId == nil { 2981 invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId")) 2982 } 2983 if invalidParams.Len() > 0 { 2984 return invalidParams 2985 } else { 2986 return nil 2987 } 2988} 2989 2990func validateOpDeleteSubscriptionDefinitionInput(v *DeleteSubscriptionDefinitionInput) error { 2991 if v == nil { 2992 return nil 2993 } 2994 invalidParams := smithy.InvalidParamsError{Context: "DeleteSubscriptionDefinitionInput"} 2995 if v.SubscriptionDefinitionId == nil { 2996 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId")) 2997 } 2998 if invalidParams.Len() > 0 { 2999 return invalidParams 3000 } else { 3001 return nil 3002 } 3003} 3004 3005func validateOpDisassociateRoleFromGroupInput(v *DisassociateRoleFromGroupInput) error { 3006 if v == nil { 3007 return nil 3008 } 3009 invalidParams := smithy.InvalidParamsError{Context: "DisassociateRoleFromGroupInput"} 3010 if v.GroupId == nil { 3011 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3012 } 3013 if invalidParams.Len() > 0 { 3014 return invalidParams 3015 } else { 3016 return nil 3017 } 3018} 3019 3020func validateOpGetAssociatedRoleInput(v *GetAssociatedRoleInput) error { 3021 if v == nil { 3022 return nil 3023 } 3024 invalidParams := smithy.InvalidParamsError{Context: "GetAssociatedRoleInput"} 3025 if v.GroupId == nil { 3026 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3027 } 3028 if invalidParams.Len() > 0 { 3029 return invalidParams 3030 } else { 3031 return nil 3032 } 3033} 3034 3035func validateOpGetBulkDeploymentStatusInput(v *GetBulkDeploymentStatusInput) error { 3036 if v == nil { 3037 return nil 3038 } 3039 invalidParams := smithy.InvalidParamsError{Context: "GetBulkDeploymentStatusInput"} 3040 if v.BulkDeploymentId == nil { 3041 invalidParams.Add(smithy.NewErrParamRequired("BulkDeploymentId")) 3042 } 3043 if invalidParams.Len() > 0 { 3044 return invalidParams 3045 } else { 3046 return nil 3047 } 3048} 3049 3050func validateOpGetConnectivityInfoInput(v *GetConnectivityInfoInput) error { 3051 if v == nil { 3052 return nil 3053 } 3054 invalidParams := smithy.InvalidParamsError{Context: "GetConnectivityInfoInput"} 3055 if v.ThingName == nil { 3056 invalidParams.Add(smithy.NewErrParamRequired("ThingName")) 3057 } 3058 if invalidParams.Len() > 0 { 3059 return invalidParams 3060 } else { 3061 return nil 3062 } 3063} 3064 3065func validateOpGetConnectorDefinitionInput(v *GetConnectorDefinitionInput) error { 3066 if v == nil { 3067 return nil 3068 } 3069 invalidParams := smithy.InvalidParamsError{Context: "GetConnectorDefinitionInput"} 3070 if v.ConnectorDefinitionId == nil { 3071 invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId")) 3072 } 3073 if invalidParams.Len() > 0 { 3074 return invalidParams 3075 } else { 3076 return nil 3077 } 3078} 3079 3080func validateOpGetConnectorDefinitionVersionInput(v *GetConnectorDefinitionVersionInput) error { 3081 if v == nil { 3082 return nil 3083 } 3084 invalidParams := smithy.InvalidParamsError{Context: "GetConnectorDefinitionVersionInput"} 3085 if v.ConnectorDefinitionId == nil { 3086 invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId")) 3087 } 3088 if v.ConnectorDefinitionVersionId == nil { 3089 invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionVersionId")) 3090 } 3091 if invalidParams.Len() > 0 { 3092 return invalidParams 3093 } else { 3094 return nil 3095 } 3096} 3097 3098func validateOpGetCoreDefinitionInput(v *GetCoreDefinitionInput) error { 3099 if v == nil { 3100 return nil 3101 } 3102 invalidParams := smithy.InvalidParamsError{Context: "GetCoreDefinitionInput"} 3103 if v.CoreDefinitionId == nil { 3104 invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId")) 3105 } 3106 if invalidParams.Len() > 0 { 3107 return invalidParams 3108 } else { 3109 return nil 3110 } 3111} 3112 3113func validateOpGetCoreDefinitionVersionInput(v *GetCoreDefinitionVersionInput) error { 3114 if v == nil { 3115 return nil 3116 } 3117 invalidParams := smithy.InvalidParamsError{Context: "GetCoreDefinitionVersionInput"} 3118 if v.CoreDefinitionId == nil { 3119 invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId")) 3120 } 3121 if v.CoreDefinitionVersionId == nil { 3122 invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionVersionId")) 3123 } 3124 if invalidParams.Len() > 0 { 3125 return invalidParams 3126 } else { 3127 return nil 3128 } 3129} 3130 3131func validateOpGetDeploymentStatusInput(v *GetDeploymentStatusInput) error { 3132 if v == nil { 3133 return nil 3134 } 3135 invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentStatusInput"} 3136 if v.DeploymentId == nil { 3137 invalidParams.Add(smithy.NewErrParamRequired("DeploymentId")) 3138 } 3139 if v.GroupId == nil { 3140 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3141 } 3142 if invalidParams.Len() > 0 { 3143 return invalidParams 3144 } else { 3145 return nil 3146 } 3147} 3148 3149func validateOpGetDeviceDefinitionInput(v *GetDeviceDefinitionInput) error { 3150 if v == nil { 3151 return nil 3152 } 3153 invalidParams := smithy.InvalidParamsError{Context: "GetDeviceDefinitionInput"} 3154 if v.DeviceDefinitionId == nil { 3155 invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId")) 3156 } 3157 if invalidParams.Len() > 0 { 3158 return invalidParams 3159 } else { 3160 return nil 3161 } 3162} 3163 3164func validateOpGetDeviceDefinitionVersionInput(v *GetDeviceDefinitionVersionInput) error { 3165 if v == nil { 3166 return nil 3167 } 3168 invalidParams := smithy.InvalidParamsError{Context: "GetDeviceDefinitionVersionInput"} 3169 if v.DeviceDefinitionId == nil { 3170 invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId")) 3171 } 3172 if v.DeviceDefinitionVersionId == nil { 3173 invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionVersionId")) 3174 } 3175 if invalidParams.Len() > 0 { 3176 return invalidParams 3177 } else { 3178 return nil 3179 } 3180} 3181 3182func validateOpGetFunctionDefinitionInput(v *GetFunctionDefinitionInput) error { 3183 if v == nil { 3184 return nil 3185 } 3186 invalidParams := smithy.InvalidParamsError{Context: "GetFunctionDefinitionInput"} 3187 if v.FunctionDefinitionId == nil { 3188 invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId")) 3189 } 3190 if invalidParams.Len() > 0 { 3191 return invalidParams 3192 } else { 3193 return nil 3194 } 3195} 3196 3197func validateOpGetFunctionDefinitionVersionInput(v *GetFunctionDefinitionVersionInput) error { 3198 if v == nil { 3199 return nil 3200 } 3201 invalidParams := smithy.InvalidParamsError{Context: "GetFunctionDefinitionVersionInput"} 3202 if v.FunctionDefinitionId == nil { 3203 invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId")) 3204 } 3205 if v.FunctionDefinitionVersionId == nil { 3206 invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionVersionId")) 3207 } 3208 if invalidParams.Len() > 0 { 3209 return invalidParams 3210 } else { 3211 return nil 3212 } 3213} 3214 3215func validateOpGetGroupCertificateAuthorityInput(v *GetGroupCertificateAuthorityInput) error { 3216 if v == nil { 3217 return nil 3218 } 3219 invalidParams := smithy.InvalidParamsError{Context: "GetGroupCertificateAuthorityInput"} 3220 if v.CertificateAuthorityId == nil { 3221 invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityId")) 3222 } 3223 if v.GroupId == nil { 3224 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3225 } 3226 if invalidParams.Len() > 0 { 3227 return invalidParams 3228 } else { 3229 return nil 3230 } 3231} 3232 3233func validateOpGetGroupCertificateConfigurationInput(v *GetGroupCertificateConfigurationInput) error { 3234 if v == nil { 3235 return nil 3236 } 3237 invalidParams := smithy.InvalidParamsError{Context: "GetGroupCertificateConfigurationInput"} 3238 if v.GroupId == nil { 3239 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3240 } 3241 if invalidParams.Len() > 0 { 3242 return invalidParams 3243 } else { 3244 return nil 3245 } 3246} 3247 3248func validateOpGetGroupInput(v *GetGroupInput) error { 3249 if v == nil { 3250 return nil 3251 } 3252 invalidParams := smithy.InvalidParamsError{Context: "GetGroupInput"} 3253 if v.GroupId == nil { 3254 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3255 } 3256 if invalidParams.Len() > 0 { 3257 return invalidParams 3258 } else { 3259 return nil 3260 } 3261} 3262 3263func validateOpGetGroupVersionInput(v *GetGroupVersionInput) error { 3264 if v == nil { 3265 return nil 3266 } 3267 invalidParams := smithy.InvalidParamsError{Context: "GetGroupVersionInput"} 3268 if v.GroupId == nil { 3269 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3270 } 3271 if v.GroupVersionId == nil { 3272 invalidParams.Add(smithy.NewErrParamRequired("GroupVersionId")) 3273 } 3274 if invalidParams.Len() > 0 { 3275 return invalidParams 3276 } else { 3277 return nil 3278 } 3279} 3280 3281func validateOpGetLoggerDefinitionInput(v *GetLoggerDefinitionInput) error { 3282 if v == nil { 3283 return nil 3284 } 3285 invalidParams := smithy.InvalidParamsError{Context: "GetLoggerDefinitionInput"} 3286 if v.LoggerDefinitionId == nil { 3287 invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId")) 3288 } 3289 if invalidParams.Len() > 0 { 3290 return invalidParams 3291 } else { 3292 return nil 3293 } 3294} 3295 3296func validateOpGetLoggerDefinitionVersionInput(v *GetLoggerDefinitionVersionInput) error { 3297 if v == nil { 3298 return nil 3299 } 3300 invalidParams := smithy.InvalidParamsError{Context: "GetLoggerDefinitionVersionInput"} 3301 if v.LoggerDefinitionId == nil { 3302 invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId")) 3303 } 3304 if v.LoggerDefinitionVersionId == nil { 3305 invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionVersionId")) 3306 } 3307 if invalidParams.Len() > 0 { 3308 return invalidParams 3309 } else { 3310 return nil 3311 } 3312} 3313 3314func validateOpGetResourceDefinitionInput(v *GetResourceDefinitionInput) error { 3315 if v == nil { 3316 return nil 3317 } 3318 invalidParams := smithy.InvalidParamsError{Context: "GetResourceDefinitionInput"} 3319 if v.ResourceDefinitionId == nil { 3320 invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId")) 3321 } 3322 if invalidParams.Len() > 0 { 3323 return invalidParams 3324 } else { 3325 return nil 3326 } 3327} 3328 3329func validateOpGetResourceDefinitionVersionInput(v *GetResourceDefinitionVersionInput) error { 3330 if v == nil { 3331 return nil 3332 } 3333 invalidParams := smithy.InvalidParamsError{Context: "GetResourceDefinitionVersionInput"} 3334 if v.ResourceDefinitionId == nil { 3335 invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId")) 3336 } 3337 if v.ResourceDefinitionVersionId == nil { 3338 invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionVersionId")) 3339 } 3340 if invalidParams.Len() > 0 { 3341 return invalidParams 3342 } else { 3343 return nil 3344 } 3345} 3346 3347func validateOpGetSubscriptionDefinitionInput(v *GetSubscriptionDefinitionInput) error { 3348 if v == nil { 3349 return nil 3350 } 3351 invalidParams := smithy.InvalidParamsError{Context: "GetSubscriptionDefinitionInput"} 3352 if v.SubscriptionDefinitionId == nil { 3353 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId")) 3354 } 3355 if invalidParams.Len() > 0 { 3356 return invalidParams 3357 } else { 3358 return nil 3359 } 3360} 3361 3362func validateOpGetSubscriptionDefinitionVersionInput(v *GetSubscriptionDefinitionVersionInput) error { 3363 if v == nil { 3364 return nil 3365 } 3366 invalidParams := smithy.InvalidParamsError{Context: "GetSubscriptionDefinitionVersionInput"} 3367 if v.SubscriptionDefinitionId == nil { 3368 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId")) 3369 } 3370 if v.SubscriptionDefinitionVersionId == nil { 3371 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionVersionId")) 3372 } 3373 if invalidParams.Len() > 0 { 3374 return invalidParams 3375 } else { 3376 return nil 3377 } 3378} 3379 3380func validateOpGetThingRuntimeConfigurationInput(v *GetThingRuntimeConfigurationInput) error { 3381 if v == nil { 3382 return nil 3383 } 3384 invalidParams := smithy.InvalidParamsError{Context: "GetThingRuntimeConfigurationInput"} 3385 if v.ThingName == nil { 3386 invalidParams.Add(smithy.NewErrParamRequired("ThingName")) 3387 } 3388 if invalidParams.Len() > 0 { 3389 return invalidParams 3390 } else { 3391 return nil 3392 } 3393} 3394 3395func validateOpListBulkDeploymentDetailedReportsInput(v *ListBulkDeploymentDetailedReportsInput) error { 3396 if v == nil { 3397 return nil 3398 } 3399 invalidParams := smithy.InvalidParamsError{Context: "ListBulkDeploymentDetailedReportsInput"} 3400 if v.BulkDeploymentId == nil { 3401 invalidParams.Add(smithy.NewErrParamRequired("BulkDeploymentId")) 3402 } 3403 if invalidParams.Len() > 0 { 3404 return invalidParams 3405 } else { 3406 return nil 3407 } 3408} 3409 3410func validateOpListConnectorDefinitionVersionsInput(v *ListConnectorDefinitionVersionsInput) error { 3411 if v == nil { 3412 return nil 3413 } 3414 invalidParams := smithy.InvalidParamsError{Context: "ListConnectorDefinitionVersionsInput"} 3415 if v.ConnectorDefinitionId == nil { 3416 invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId")) 3417 } 3418 if invalidParams.Len() > 0 { 3419 return invalidParams 3420 } else { 3421 return nil 3422 } 3423} 3424 3425func validateOpListCoreDefinitionVersionsInput(v *ListCoreDefinitionVersionsInput) error { 3426 if v == nil { 3427 return nil 3428 } 3429 invalidParams := smithy.InvalidParamsError{Context: "ListCoreDefinitionVersionsInput"} 3430 if v.CoreDefinitionId == nil { 3431 invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId")) 3432 } 3433 if invalidParams.Len() > 0 { 3434 return invalidParams 3435 } else { 3436 return nil 3437 } 3438} 3439 3440func validateOpListDeploymentsInput(v *ListDeploymentsInput) error { 3441 if v == nil { 3442 return nil 3443 } 3444 invalidParams := smithy.InvalidParamsError{Context: "ListDeploymentsInput"} 3445 if v.GroupId == nil { 3446 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3447 } 3448 if invalidParams.Len() > 0 { 3449 return invalidParams 3450 } else { 3451 return nil 3452 } 3453} 3454 3455func validateOpListDeviceDefinitionVersionsInput(v *ListDeviceDefinitionVersionsInput) error { 3456 if v == nil { 3457 return nil 3458 } 3459 invalidParams := smithy.InvalidParamsError{Context: "ListDeviceDefinitionVersionsInput"} 3460 if v.DeviceDefinitionId == nil { 3461 invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId")) 3462 } 3463 if invalidParams.Len() > 0 { 3464 return invalidParams 3465 } else { 3466 return nil 3467 } 3468} 3469 3470func validateOpListFunctionDefinitionVersionsInput(v *ListFunctionDefinitionVersionsInput) error { 3471 if v == nil { 3472 return nil 3473 } 3474 invalidParams := smithy.InvalidParamsError{Context: "ListFunctionDefinitionVersionsInput"} 3475 if v.FunctionDefinitionId == nil { 3476 invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId")) 3477 } 3478 if invalidParams.Len() > 0 { 3479 return invalidParams 3480 } else { 3481 return nil 3482 } 3483} 3484 3485func validateOpListGroupCertificateAuthoritiesInput(v *ListGroupCertificateAuthoritiesInput) error { 3486 if v == nil { 3487 return nil 3488 } 3489 invalidParams := smithy.InvalidParamsError{Context: "ListGroupCertificateAuthoritiesInput"} 3490 if v.GroupId == nil { 3491 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3492 } 3493 if invalidParams.Len() > 0 { 3494 return invalidParams 3495 } else { 3496 return nil 3497 } 3498} 3499 3500func validateOpListGroupVersionsInput(v *ListGroupVersionsInput) error { 3501 if v == nil { 3502 return nil 3503 } 3504 invalidParams := smithy.InvalidParamsError{Context: "ListGroupVersionsInput"} 3505 if v.GroupId == nil { 3506 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3507 } 3508 if invalidParams.Len() > 0 { 3509 return invalidParams 3510 } else { 3511 return nil 3512 } 3513} 3514 3515func validateOpListLoggerDefinitionVersionsInput(v *ListLoggerDefinitionVersionsInput) error { 3516 if v == nil { 3517 return nil 3518 } 3519 invalidParams := smithy.InvalidParamsError{Context: "ListLoggerDefinitionVersionsInput"} 3520 if v.LoggerDefinitionId == nil { 3521 invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId")) 3522 } 3523 if invalidParams.Len() > 0 { 3524 return invalidParams 3525 } else { 3526 return nil 3527 } 3528} 3529 3530func validateOpListResourceDefinitionVersionsInput(v *ListResourceDefinitionVersionsInput) error { 3531 if v == nil { 3532 return nil 3533 } 3534 invalidParams := smithy.InvalidParamsError{Context: "ListResourceDefinitionVersionsInput"} 3535 if v.ResourceDefinitionId == nil { 3536 invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId")) 3537 } 3538 if invalidParams.Len() > 0 { 3539 return invalidParams 3540 } else { 3541 return nil 3542 } 3543} 3544 3545func validateOpListSubscriptionDefinitionVersionsInput(v *ListSubscriptionDefinitionVersionsInput) error { 3546 if v == nil { 3547 return nil 3548 } 3549 invalidParams := smithy.InvalidParamsError{Context: "ListSubscriptionDefinitionVersionsInput"} 3550 if v.SubscriptionDefinitionId == nil { 3551 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId")) 3552 } 3553 if invalidParams.Len() > 0 { 3554 return invalidParams 3555 } else { 3556 return nil 3557 } 3558} 3559 3560func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 3561 if v == nil { 3562 return nil 3563 } 3564 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 3565 if v.ResourceArn == nil { 3566 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3567 } 3568 if invalidParams.Len() > 0 { 3569 return invalidParams 3570 } else { 3571 return nil 3572 } 3573} 3574 3575func validateOpResetDeploymentsInput(v *ResetDeploymentsInput) error { 3576 if v == nil { 3577 return nil 3578 } 3579 invalidParams := smithy.InvalidParamsError{Context: "ResetDeploymentsInput"} 3580 if v.GroupId == nil { 3581 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3582 } 3583 if invalidParams.Len() > 0 { 3584 return invalidParams 3585 } else { 3586 return nil 3587 } 3588} 3589 3590func validateOpStartBulkDeploymentInput(v *StartBulkDeploymentInput) error { 3591 if v == nil { 3592 return nil 3593 } 3594 invalidParams := smithy.InvalidParamsError{Context: "StartBulkDeploymentInput"} 3595 if v.ExecutionRoleArn == nil { 3596 invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn")) 3597 } 3598 if v.InputFileUri == nil { 3599 invalidParams.Add(smithy.NewErrParamRequired("InputFileUri")) 3600 } 3601 if invalidParams.Len() > 0 { 3602 return invalidParams 3603 } else { 3604 return nil 3605 } 3606} 3607 3608func validateOpStopBulkDeploymentInput(v *StopBulkDeploymentInput) error { 3609 if v == nil { 3610 return nil 3611 } 3612 invalidParams := smithy.InvalidParamsError{Context: "StopBulkDeploymentInput"} 3613 if v.BulkDeploymentId == nil { 3614 invalidParams.Add(smithy.NewErrParamRequired("BulkDeploymentId")) 3615 } 3616 if invalidParams.Len() > 0 { 3617 return invalidParams 3618 } else { 3619 return nil 3620 } 3621} 3622 3623func validateOpTagResourceInput(v *TagResourceInput) error { 3624 if v == nil { 3625 return nil 3626 } 3627 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 3628 if v.ResourceArn == nil { 3629 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3630 } 3631 if invalidParams.Len() > 0 { 3632 return invalidParams 3633 } else { 3634 return nil 3635 } 3636} 3637 3638func validateOpUntagResourceInput(v *UntagResourceInput) error { 3639 if v == nil { 3640 return nil 3641 } 3642 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 3643 if v.ResourceArn == nil { 3644 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3645 } 3646 if v.TagKeys == nil { 3647 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 3648 } 3649 if invalidParams.Len() > 0 { 3650 return invalidParams 3651 } else { 3652 return nil 3653 } 3654} 3655 3656func validateOpUpdateConnectivityInfoInput(v *UpdateConnectivityInfoInput) error { 3657 if v == nil { 3658 return nil 3659 } 3660 invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectivityInfoInput"} 3661 if v.ThingName == nil { 3662 invalidParams.Add(smithy.NewErrParamRequired("ThingName")) 3663 } 3664 if invalidParams.Len() > 0 { 3665 return invalidParams 3666 } else { 3667 return nil 3668 } 3669} 3670 3671func validateOpUpdateConnectorDefinitionInput(v *UpdateConnectorDefinitionInput) error { 3672 if v == nil { 3673 return nil 3674 } 3675 invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectorDefinitionInput"} 3676 if v.ConnectorDefinitionId == nil { 3677 invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId")) 3678 } 3679 if invalidParams.Len() > 0 { 3680 return invalidParams 3681 } else { 3682 return nil 3683 } 3684} 3685 3686func validateOpUpdateCoreDefinitionInput(v *UpdateCoreDefinitionInput) error { 3687 if v == nil { 3688 return nil 3689 } 3690 invalidParams := smithy.InvalidParamsError{Context: "UpdateCoreDefinitionInput"} 3691 if v.CoreDefinitionId == nil { 3692 invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId")) 3693 } 3694 if invalidParams.Len() > 0 { 3695 return invalidParams 3696 } else { 3697 return nil 3698 } 3699} 3700 3701func validateOpUpdateDeviceDefinitionInput(v *UpdateDeviceDefinitionInput) error { 3702 if v == nil { 3703 return nil 3704 } 3705 invalidParams := smithy.InvalidParamsError{Context: "UpdateDeviceDefinitionInput"} 3706 if v.DeviceDefinitionId == nil { 3707 invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId")) 3708 } 3709 if invalidParams.Len() > 0 { 3710 return invalidParams 3711 } else { 3712 return nil 3713 } 3714} 3715 3716func validateOpUpdateFunctionDefinitionInput(v *UpdateFunctionDefinitionInput) error { 3717 if v == nil { 3718 return nil 3719 } 3720 invalidParams := smithy.InvalidParamsError{Context: "UpdateFunctionDefinitionInput"} 3721 if v.FunctionDefinitionId == nil { 3722 invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId")) 3723 } 3724 if invalidParams.Len() > 0 { 3725 return invalidParams 3726 } else { 3727 return nil 3728 } 3729} 3730 3731func validateOpUpdateGroupCertificateConfigurationInput(v *UpdateGroupCertificateConfigurationInput) error { 3732 if v == nil { 3733 return nil 3734 } 3735 invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupCertificateConfigurationInput"} 3736 if v.GroupId == nil { 3737 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3738 } 3739 if invalidParams.Len() > 0 { 3740 return invalidParams 3741 } else { 3742 return nil 3743 } 3744} 3745 3746func validateOpUpdateGroupInput(v *UpdateGroupInput) error { 3747 if v == nil { 3748 return nil 3749 } 3750 invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupInput"} 3751 if v.GroupId == nil { 3752 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 3753 } 3754 if invalidParams.Len() > 0 { 3755 return invalidParams 3756 } else { 3757 return nil 3758 } 3759} 3760 3761func validateOpUpdateLoggerDefinitionInput(v *UpdateLoggerDefinitionInput) error { 3762 if v == nil { 3763 return nil 3764 } 3765 invalidParams := smithy.InvalidParamsError{Context: "UpdateLoggerDefinitionInput"} 3766 if v.LoggerDefinitionId == nil { 3767 invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId")) 3768 } 3769 if invalidParams.Len() > 0 { 3770 return invalidParams 3771 } else { 3772 return nil 3773 } 3774} 3775 3776func validateOpUpdateResourceDefinitionInput(v *UpdateResourceDefinitionInput) error { 3777 if v == nil { 3778 return nil 3779 } 3780 invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceDefinitionInput"} 3781 if v.ResourceDefinitionId == nil { 3782 invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId")) 3783 } 3784 if invalidParams.Len() > 0 { 3785 return invalidParams 3786 } else { 3787 return nil 3788 } 3789} 3790 3791func validateOpUpdateSubscriptionDefinitionInput(v *UpdateSubscriptionDefinitionInput) error { 3792 if v == nil { 3793 return nil 3794 } 3795 invalidParams := smithy.InvalidParamsError{Context: "UpdateSubscriptionDefinitionInput"} 3796 if v.SubscriptionDefinitionId == nil { 3797 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId")) 3798 } 3799 if invalidParams.Len() > 0 { 3800 return invalidParams 3801 } else { 3802 return nil 3803 } 3804} 3805 3806func validateOpUpdateThingRuntimeConfigurationInput(v *UpdateThingRuntimeConfigurationInput) error { 3807 if v == nil { 3808 return nil 3809 } 3810 invalidParams := smithy.InvalidParamsError{Context: "UpdateThingRuntimeConfigurationInput"} 3811 if v.TelemetryConfiguration != nil { 3812 if err := validateTelemetryConfigurationUpdate(v.TelemetryConfiguration); err != nil { 3813 invalidParams.AddNested("TelemetryConfiguration", err.(smithy.InvalidParamsError)) 3814 } 3815 } 3816 if v.ThingName == nil { 3817 invalidParams.Add(smithy.NewErrParamRequired("ThingName")) 3818 } 3819 if invalidParams.Len() > 0 { 3820 return invalidParams 3821 } else { 3822 return nil 3823 } 3824} 3825