1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package workspaces 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/workspaces/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAssociateConnectionAlias struct { 14} 15 16func (*validateOpAssociateConnectionAlias) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAssociateConnectionAlias) 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.(*AssociateConnectionAliasInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAssociateConnectionAliasInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAssociateIpGroups struct { 34} 35 36func (*validateOpAssociateIpGroups) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAssociateIpGroups) 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.(*AssociateIpGroupsInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAssociateIpGroupsInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpAuthorizeIpRules struct { 54} 55 56func (*validateOpAuthorizeIpRules) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpAuthorizeIpRules) 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.(*AuthorizeIpRulesInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpAuthorizeIpRulesInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCopyWorkspaceImage struct { 74} 75 76func (*validateOpCopyWorkspaceImage) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCopyWorkspaceImage) 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.(*CopyWorkspaceImageInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCopyWorkspaceImageInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateConnectionAlias struct { 94} 95 96func (*validateOpCreateConnectionAlias) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateConnectionAlias) 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.(*CreateConnectionAliasInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateConnectionAliasInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateIpGroup struct { 114} 115 116func (*validateOpCreateIpGroup) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateIpGroup) 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.(*CreateIpGroupInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateIpGroupInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateTags struct { 134} 135 136func (*validateOpCreateTags) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateTags) 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.(*CreateTagsInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateTagsInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreateWorkspaceBundle struct { 154} 155 156func (*validateOpCreateWorkspaceBundle) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreateWorkspaceBundle) 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.(*CreateWorkspaceBundleInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreateWorkspaceBundleInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpCreateWorkspaces struct { 174} 175 176func (*validateOpCreateWorkspaces) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpCreateWorkspaces) 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.(*CreateWorkspacesInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpCreateWorkspacesInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteConnectionAlias struct { 194} 195 196func (*validateOpDeleteConnectionAlias) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteConnectionAlias) 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.(*DeleteConnectionAliasInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteConnectionAliasInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteIpGroup struct { 214} 215 216func (*validateOpDeleteIpGroup) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteIpGroup) 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.(*DeleteIpGroupInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteIpGroupInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteTags struct { 234} 235 236func (*validateOpDeleteTags) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteTags) 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.(*DeleteTagsInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteTagsInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteWorkspaceImage struct { 254} 255 256func (*validateOpDeleteWorkspaceImage) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteWorkspaceImage) 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.(*DeleteWorkspaceImageInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteWorkspaceImageInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeregisterWorkspaceDirectory struct { 274} 275 276func (*validateOpDeregisterWorkspaceDirectory) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeregisterWorkspaceDirectory) 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.(*DeregisterWorkspaceDirectoryInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeregisterWorkspaceDirectoryInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDescribeClientProperties struct { 294} 295 296func (*validateOpDescribeClientProperties) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDescribeClientProperties) 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.(*DescribeClientPropertiesInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDescribeClientPropertiesInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDescribeConnectionAliasPermissions struct { 314} 315 316func (*validateOpDescribeConnectionAliasPermissions) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDescribeConnectionAliasPermissions) 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.(*DescribeConnectionAliasPermissionsInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDescribeConnectionAliasPermissionsInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDescribeTags struct { 334} 335 336func (*validateOpDescribeTags) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDescribeTags) 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.(*DescribeTagsInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDescribeTagsInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDescribeWorkspaceImagePermissions struct { 354} 355 356func (*validateOpDescribeWorkspaceImagePermissions) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDescribeWorkspaceImagePermissions) 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.(*DescribeWorkspaceImagePermissionsInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDescribeWorkspaceImagePermissionsInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDescribeWorkspaceSnapshots struct { 374} 375 376func (*validateOpDescribeWorkspaceSnapshots) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDescribeWorkspaceSnapshots) 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.(*DescribeWorkspaceSnapshotsInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDescribeWorkspaceSnapshotsInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDisassociateConnectionAlias struct { 394} 395 396func (*validateOpDisassociateConnectionAlias) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDisassociateConnectionAlias) 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.(*DisassociateConnectionAliasInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDisassociateConnectionAliasInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDisassociateIpGroups struct { 414} 415 416func (*validateOpDisassociateIpGroups) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDisassociateIpGroups) 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.(*DisassociateIpGroupsInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDisassociateIpGroupsInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpImportWorkspaceImage struct { 434} 435 436func (*validateOpImportWorkspaceImage) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpImportWorkspaceImage) 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.(*ImportWorkspaceImageInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpImportWorkspaceImageInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpListAvailableManagementCidrRanges struct { 454} 455 456func (*validateOpListAvailableManagementCidrRanges) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpListAvailableManagementCidrRanges) 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.(*ListAvailableManagementCidrRangesInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpListAvailableManagementCidrRangesInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpMigrateWorkspace struct { 474} 475 476func (*validateOpMigrateWorkspace) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpMigrateWorkspace) 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.(*MigrateWorkspaceInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpMigrateWorkspaceInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpModifyClientProperties struct { 494} 495 496func (*validateOpModifyClientProperties) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpModifyClientProperties) 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.(*ModifyClientPropertiesInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpModifyClientPropertiesInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpModifySelfservicePermissions struct { 514} 515 516func (*validateOpModifySelfservicePermissions) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpModifySelfservicePermissions) 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.(*ModifySelfservicePermissionsInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpModifySelfservicePermissionsInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpModifyWorkspaceAccessProperties struct { 534} 535 536func (*validateOpModifyWorkspaceAccessProperties) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpModifyWorkspaceAccessProperties) 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.(*ModifyWorkspaceAccessPropertiesInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpModifyWorkspaceAccessPropertiesInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpModifyWorkspaceCreationProperties struct { 554} 555 556func (*validateOpModifyWorkspaceCreationProperties) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpModifyWorkspaceCreationProperties) 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.(*ModifyWorkspaceCreationPropertiesInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpModifyWorkspaceCreationPropertiesInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpModifyWorkspaceProperties struct { 574} 575 576func (*validateOpModifyWorkspaceProperties) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpModifyWorkspaceProperties) 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.(*ModifyWorkspacePropertiesInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpModifyWorkspacePropertiesInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpModifyWorkspaceState struct { 594} 595 596func (*validateOpModifyWorkspaceState) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpModifyWorkspaceState) 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.(*ModifyWorkspaceStateInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpModifyWorkspaceStateInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpRebootWorkspaces struct { 614} 615 616func (*validateOpRebootWorkspaces) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpRebootWorkspaces) 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.(*RebootWorkspacesInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpRebootWorkspacesInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpRebuildWorkspaces struct { 634} 635 636func (*validateOpRebuildWorkspaces) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpRebuildWorkspaces) 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.(*RebuildWorkspacesInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpRebuildWorkspacesInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpRegisterWorkspaceDirectory struct { 654} 655 656func (*validateOpRegisterWorkspaceDirectory) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpRegisterWorkspaceDirectory) 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.(*RegisterWorkspaceDirectoryInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpRegisterWorkspaceDirectoryInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpRestoreWorkspace struct { 674} 675 676func (*validateOpRestoreWorkspace) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpRestoreWorkspace) 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.(*RestoreWorkspaceInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpRestoreWorkspaceInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpRevokeIpRules struct { 694} 695 696func (*validateOpRevokeIpRules) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpRevokeIpRules) 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.(*RevokeIpRulesInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpRevokeIpRulesInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpStartWorkspaces struct { 714} 715 716func (*validateOpStartWorkspaces) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpStartWorkspaces) 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.(*StartWorkspacesInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpStartWorkspacesInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpStopWorkspaces struct { 734} 735 736func (*validateOpStopWorkspaces) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpStopWorkspaces) 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.(*StopWorkspacesInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpStopWorkspacesInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpTerminateWorkspaces struct { 754} 755 756func (*validateOpTerminateWorkspaces) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpTerminateWorkspaces) 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.(*TerminateWorkspacesInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpTerminateWorkspacesInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpUpdateConnectionAliasPermission struct { 774} 775 776func (*validateOpUpdateConnectionAliasPermission) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpUpdateConnectionAliasPermission) 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.(*UpdateConnectionAliasPermissionInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpUpdateConnectionAliasPermissionInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpUpdateRulesOfIpGroup struct { 794} 795 796func (*validateOpUpdateRulesOfIpGroup) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpUpdateRulesOfIpGroup) 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.(*UpdateRulesOfIpGroupInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpUpdateRulesOfIpGroupInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpUpdateWorkspaceImagePermission struct { 814} 815 816func (*validateOpUpdateWorkspaceImagePermission) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpUpdateWorkspaceImagePermission) 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.(*UpdateWorkspaceImagePermissionInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpUpdateWorkspaceImagePermissionInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833func addOpAssociateConnectionAliasValidationMiddleware(stack *middleware.Stack) error { 834 return stack.Initialize.Add(&validateOpAssociateConnectionAlias{}, middleware.After) 835} 836 837func addOpAssociateIpGroupsValidationMiddleware(stack *middleware.Stack) error { 838 return stack.Initialize.Add(&validateOpAssociateIpGroups{}, middleware.After) 839} 840 841func addOpAuthorizeIpRulesValidationMiddleware(stack *middleware.Stack) error { 842 return stack.Initialize.Add(&validateOpAuthorizeIpRules{}, middleware.After) 843} 844 845func addOpCopyWorkspaceImageValidationMiddleware(stack *middleware.Stack) error { 846 return stack.Initialize.Add(&validateOpCopyWorkspaceImage{}, middleware.After) 847} 848 849func addOpCreateConnectionAliasValidationMiddleware(stack *middleware.Stack) error { 850 return stack.Initialize.Add(&validateOpCreateConnectionAlias{}, middleware.After) 851} 852 853func addOpCreateIpGroupValidationMiddleware(stack *middleware.Stack) error { 854 return stack.Initialize.Add(&validateOpCreateIpGroup{}, middleware.After) 855} 856 857func addOpCreateTagsValidationMiddleware(stack *middleware.Stack) error { 858 return stack.Initialize.Add(&validateOpCreateTags{}, middleware.After) 859} 860 861func addOpCreateWorkspaceBundleValidationMiddleware(stack *middleware.Stack) error { 862 return stack.Initialize.Add(&validateOpCreateWorkspaceBundle{}, middleware.After) 863} 864 865func addOpCreateWorkspacesValidationMiddleware(stack *middleware.Stack) error { 866 return stack.Initialize.Add(&validateOpCreateWorkspaces{}, middleware.After) 867} 868 869func addOpDeleteConnectionAliasValidationMiddleware(stack *middleware.Stack) error { 870 return stack.Initialize.Add(&validateOpDeleteConnectionAlias{}, middleware.After) 871} 872 873func addOpDeleteIpGroupValidationMiddleware(stack *middleware.Stack) error { 874 return stack.Initialize.Add(&validateOpDeleteIpGroup{}, middleware.After) 875} 876 877func addOpDeleteTagsValidationMiddleware(stack *middleware.Stack) error { 878 return stack.Initialize.Add(&validateOpDeleteTags{}, middleware.After) 879} 880 881func addOpDeleteWorkspaceImageValidationMiddleware(stack *middleware.Stack) error { 882 return stack.Initialize.Add(&validateOpDeleteWorkspaceImage{}, middleware.After) 883} 884 885func addOpDeregisterWorkspaceDirectoryValidationMiddleware(stack *middleware.Stack) error { 886 return stack.Initialize.Add(&validateOpDeregisterWorkspaceDirectory{}, middleware.After) 887} 888 889func addOpDescribeClientPropertiesValidationMiddleware(stack *middleware.Stack) error { 890 return stack.Initialize.Add(&validateOpDescribeClientProperties{}, middleware.After) 891} 892 893func addOpDescribeConnectionAliasPermissionsValidationMiddleware(stack *middleware.Stack) error { 894 return stack.Initialize.Add(&validateOpDescribeConnectionAliasPermissions{}, middleware.After) 895} 896 897func addOpDescribeTagsValidationMiddleware(stack *middleware.Stack) error { 898 return stack.Initialize.Add(&validateOpDescribeTags{}, middleware.After) 899} 900 901func addOpDescribeWorkspaceImagePermissionsValidationMiddleware(stack *middleware.Stack) error { 902 return stack.Initialize.Add(&validateOpDescribeWorkspaceImagePermissions{}, middleware.After) 903} 904 905func addOpDescribeWorkspaceSnapshotsValidationMiddleware(stack *middleware.Stack) error { 906 return stack.Initialize.Add(&validateOpDescribeWorkspaceSnapshots{}, middleware.After) 907} 908 909func addOpDisassociateConnectionAliasValidationMiddleware(stack *middleware.Stack) error { 910 return stack.Initialize.Add(&validateOpDisassociateConnectionAlias{}, middleware.After) 911} 912 913func addOpDisassociateIpGroupsValidationMiddleware(stack *middleware.Stack) error { 914 return stack.Initialize.Add(&validateOpDisassociateIpGroups{}, middleware.After) 915} 916 917func addOpImportWorkspaceImageValidationMiddleware(stack *middleware.Stack) error { 918 return stack.Initialize.Add(&validateOpImportWorkspaceImage{}, middleware.After) 919} 920 921func addOpListAvailableManagementCidrRangesValidationMiddleware(stack *middleware.Stack) error { 922 return stack.Initialize.Add(&validateOpListAvailableManagementCidrRanges{}, middleware.After) 923} 924 925func addOpMigrateWorkspaceValidationMiddleware(stack *middleware.Stack) error { 926 return stack.Initialize.Add(&validateOpMigrateWorkspace{}, middleware.After) 927} 928 929func addOpModifyClientPropertiesValidationMiddleware(stack *middleware.Stack) error { 930 return stack.Initialize.Add(&validateOpModifyClientProperties{}, middleware.After) 931} 932 933func addOpModifySelfservicePermissionsValidationMiddleware(stack *middleware.Stack) error { 934 return stack.Initialize.Add(&validateOpModifySelfservicePermissions{}, middleware.After) 935} 936 937func addOpModifyWorkspaceAccessPropertiesValidationMiddleware(stack *middleware.Stack) error { 938 return stack.Initialize.Add(&validateOpModifyWorkspaceAccessProperties{}, middleware.After) 939} 940 941func addOpModifyWorkspaceCreationPropertiesValidationMiddleware(stack *middleware.Stack) error { 942 return stack.Initialize.Add(&validateOpModifyWorkspaceCreationProperties{}, middleware.After) 943} 944 945func addOpModifyWorkspacePropertiesValidationMiddleware(stack *middleware.Stack) error { 946 return stack.Initialize.Add(&validateOpModifyWorkspaceProperties{}, middleware.After) 947} 948 949func addOpModifyWorkspaceStateValidationMiddleware(stack *middleware.Stack) error { 950 return stack.Initialize.Add(&validateOpModifyWorkspaceState{}, middleware.After) 951} 952 953func addOpRebootWorkspacesValidationMiddleware(stack *middleware.Stack) error { 954 return stack.Initialize.Add(&validateOpRebootWorkspaces{}, middleware.After) 955} 956 957func addOpRebuildWorkspacesValidationMiddleware(stack *middleware.Stack) error { 958 return stack.Initialize.Add(&validateOpRebuildWorkspaces{}, middleware.After) 959} 960 961func addOpRegisterWorkspaceDirectoryValidationMiddleware(stack *middleware.Stack) error { 962 return stack.Initialize.Add(&validateOpRegisterWorkspaceDirectory{}, middleware.After) 963} 964 965func addOpRestoreWorkspaceValidationMiddleware(stack *middleware.Stack) error { 966 return stack.Initialize.Add(&validateOpRestoreWorkspace{}, middleware.After) 967} 968 969func addOpRevokeIpRulesValidationMiddleware(stack *middleware.Stack) error { 970 return stack.Initialize.Add(&validateOpRevokeIpRules{}, middleware.After) 971} 972 973func addOpStartWorkspacesValidationMiddleware(stack *middleware.Stack) error { 974 return stack.Initialize.Add(&validateOpStartWorkspaces{}, middleware.After) 975} 976 977func addOpStopWorkspacesValidationMiddleware(stack *middleware.Stack) error { 978 return stack.Initialize.Add(&validateOpStopWorkspaces{}, middleware.After) 979} 980 981func addOpTerminateWorkspacesValidationMiddleware(stack *middleware.Stack) error { 982 return stack.Initialize.Add(&validateOpTerminateWorkspaces{}, middleware.After) 983} 984 985func addOpUpdateConnectionAliasPermissionValidationMiddleware(stack *middleware.Stack) error { 986 return stack.Initialize.Add(&validateOpUpdateConnectionAliasPermission{}, middleware.After) 987} 988 989func addOpUpdateRulesOfIpGroupValidationMiddleware(stack *middleware.Stack) error { 990 return stack.Initialize.Add(&validateOpUpdateRulesOfIpGroup{}, middleware.After) 991} 992 993func addOpUpdateWorkspaceImagePermissionValidationMiddleware(stack *middleware.Stack) error { 994 return stack.Initialize.Add(&validateOpUpdateWorkspaceImagePermission{}, middleware.After) 995} 996 997func validateConnectionAliasPermission(v *types.ConnectionAliasPermission) error { 998 if v == nil { 999 return nil 1000 } 1001 invalidParams := smithy.InvalidParamsError{Context: "ConnectionAliasPermission"} 1002 if v.SharedAccountId == nil { 1003 invalidParams.Add(smithy.NewErrParamRequired("SharedAccountId")) 1004 } 1005 if v.AllowAssociation == nil { 1006 invalidParams.Add(smithy.NewErrParamRequired("AllowAssociation")) 1007 } 1008 if invalidParams.Len() > 0 { 1009 return invalidParams 1010 } else { 1011 return nil 1012 } 1013} 1014 1015func validateRebootRequest(v *types.RebootRequest) error { 1016 if v == nil { 1017 return nil 1018 } 1019 invalidParams := smithy.InvalidParamsError{Context: "RebootRequest"} 1020 if v.WorkspaceId == nil { 1021 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId")) 1022 } 1023 if invalidParams.Len() > 0 { 1024 return invalidParams 1025 } else { 1026 return nil 1027 } 1028} 1029 1030func validateRebootWorkspaceRequests(v []types.RebootRequest) error { 1031 if v == nil { 1032 return nil 1033 } 1034 invalidParams := smithy.InvalidParamsError{Context: "RebootWorkspaceRequests"} 1035 for i := range v { 1036 if err := validateRebootRequest(&v[i]); err != nil { 1037 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1038 } 1039 } 1040 if invalidParams.Len() > 0 { 1041 return invalidParams 1042 } else { 1043 return nil 1044 } 1045} 1046 1047func validateRebuildRequest(v *types.RebuildRequest) error { 1048 if v == nil { 1049 return nil 1050 } 1051 invalidParams := smithy.InvalidParamsError{Context: "RebuildRequest"} 1052 if v.WorkspaceId == nil { 1053 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId")) 1054 } 1055 if invalidParams.Len() > 0 { 1056 return invalidParams 1057 } else { 1058 return nil 1059 } 1060} 1061 1062func validateRebuildWorkspaceRequests(v []types.RebuildRequest) error { 1063 if v == nil { 1064 return nil 1065 } 1066 invalidParams := smithy.InvalidParamsError{Context: "RebuildWorkspaceRequests"} 1067 for i := range v { 1068 if err := validateRebuildRequest(&v[i]); err != nil { 1069 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1070 } 1071 } 1072 if invalidParams.Len() > 0 { 1073 return invalidParams 1074 } else { 1075 return nil 1076 } 1077} 1078 1079func validateTag(v *types.Tag) error { 1080 if v == nil { 1081 return nil 1082 } 1083 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1084 if v.Key == nil { 1085 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1086 } 1087 if invalidParams.Len() > 0 { 1088 return invalidParams 1089 } else { 1090 return nil 1091 } 1092} 1093 1094func validateTagList(v []types.Tag) error { 1095 if v == nil { 1096 return nil 1097 } 1098 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1099 for i := range v { 1100 if err := validateTag(&v[i]); err != nil { 1101 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1102 } 1103 } 1104 if invalidParams.Len() > 0 { 1105 return invalidParams 1106 } else { 1107 return nil 1108 } 1109} 1110 1111func validateTerminateRequest(v *types.TerminateRequest) error { 1112 if v == nil { 1113 return nil 1114 } 1115 invalidParams := smithy.InvalidParamsError{Context: "TerminateRequest"} 1116 if v.WorkspaceId == nil { 1117 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId")) 1118 } 1119 if invalidParams.Len() > 0 { 1120 return invalidParams 1121 } else { 1122 return nil 1123 } 1124} 1125 1126func validateTerminateWorkspaceRequests(v []types.TerminateRequest) error { 1127 if v == nil { 1128 return nil 1129 } 1130 invalidParams := smithy.InvalidParamsError{Context: "TerminateWorkspaceRequests"} 1131 for i := range v { 1132 if err := validateTerminateRequest(&v[i]); err != nil { 1133 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1134 } 1135 } 1136 if invalidParams.Len() > 0 { 1137 return invalidParams 1138 } else { 1139 return nil 1140 } 1141} 1142 1143func validateWorkspaceRequest(v *types.WorkspaceRequest) error { 1144 if v == nil { 1145 return nil 1146 } 1147 invalidParams := smithy.InvalidParamsError{Context: "WorkspaceRequest"} 1148 if v.DirectoryId == nil { 1149 invalidParams.Add(smithy.NewErrParamRequired("DirectoryId")) 1150 } 1151 if v.UserName == nil { 1152 invalidParams.Add(smithy.NewErrParamRequired("UserName")) 1153 } 1154 if v.BundleId == nil { 1155 invalidParams.Add(smithy.NewErrParamRequired("BundleId")) 1156 } 1157 if v.Tags != nil { 1158 if err := validateTagList(v.Tags); err != nil { 1159 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1160 } 1161 } 1162 if invalidParams.Len() > 0 { 1163 return invalidParams 1164 } else { 1165 return nil 1166 } 1167} 1168 1169func validateWorkspaceRequestList(v []types.WorkspaceRequest) error { 1170 if v == nil { 1171 return nil 1172 } 1173 invalidParams := smithy.InvalidParamsError{Context: "WorkspaceRequestList"} 1174 for i := range v { 1175 if err := validateWorkspaceRequest(&v[i]); err != nil { 1176 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1177 } 1178 } 1179 if invalidParams.Len() > 0 { 1180 return invalidParams 1181 } else { 1182 return nil 1183 } 1184} 1185 1186func validateOpAssociateConnectionAliasInput(v *AssociateConnectionAliasInput) error { 1187 if v == nil { 1188 return nil 1189 } 1190 invalidParams := smithy.InvalidParamsError{Context: "AssociateConnectionAliasInput"} 1191 if v.AliasId == nil { 1192 invalidParams.Add(smithy.NewErrParamRequired("AliasId")) 1193 } 1194 if v.ResourceId == nil { 1195 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1196 } 1197 if invalidParams.Len() > 0 { 1198 return invalidParams 1199 } else { 1200 return nil 1201 } 1202} 1203 1204func validateOpAssociateIpGroupsInput(v *AssociateIpGroupsInput) error { 1205 if v == nil { 1206 return nil 1207 } 1208 invalidParams := smithy.InvalidParamsError{Context: "AssociateIpGroupsInput"} 1209 if v.DirectoryId == nil { 1210 invalidParams.Add(smithy.NewErrParamRequired("DirectoryId")) 1211 } 1212 if v.GroupIds == nil { 1213 invalidParams.Add(smithy.NewErrParamRequired("GroupIds")) 1214 } 1215 if invalidParams.Len() > 0 { 1216 return invalidParams 1217 } else { 1218 return nil 1219 } 1220} 1221 1222func validateOpAuthorizeIpRulesInput(v *AuthorizeIpRulesInput) error { 1223 if v == nil { 1224 return nil 1225 } 1226 invalidParams := smithy.InvalidParamsError{Context: "AuthorizeIpRulesInput"} 1227 if v.GroupId == nil { 1228 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 1229 } 1230 if v.UserRules == nil { 1231 invalidParams.Add(smithy.NewErrParamRequired("UserRules")) 1232 } 1233 if invalidParams.Len() > 0 { 1234 return invalidParams 1235 } else { 1236 return nil 1237 } 1238} 1239 1240func validateOpCopyWorkspaceImageInput(v *CopyWorkspaceImageInput) error { 1241 if v == nil { 1242 return nil 1243 } 1244 invalidParams := smithy.InvalidParamsError{Context: "CopyWorkspaceImageInput"} 1245 if v.Name == nil { 1246 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1247 } 1248 if v.SourceImageId == nil { 1249 invalidParams.Add(smithy.NewErrParamRequired("SourceImageId")) 1250 } 1251 if v.SourceRegion == nil { 1252 invalidParams.Add(smithy.NewErrParamRequired("SourceRegion")) 1253 } 1254 if v.Tags != nil { 1255 if err := validateTagList(v.Tags); err != nil { 1256 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1257 } 1258 } 1259 if invalidParams.Len() > 0 { 1260 return invalidParams 1261 } else { 1262 return nil 1263 } 1264} 1265 1266func validateOpCreateConnectionAliasInput(v *CreateConnectionAliasInput) error { 1267 if v == nil { 1268 return nil 1269 } 1270 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionAliasInput"} 1271 if v.ConnectionString == nil { 1272 invalidParams.Add(smithy.NewErrParamRequired("ConnectionString")) 1273 } 1274 if v.Tags != nil { 1275 if err := validateTagList(v.Tags); err != nil { 1276 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1277 } 1278 } 1279 if invalidParams.Len() > 0 { 1280 return invalidParams 1281 } else { 1282 return nil 1283 } 1284} 1285 1286func validateOpCreateIpGroupInput(v *CreateIpGroupInput) error { 1287 if v == nil { 1288 return nil 1289 } 1290 invalidParams := smithy.InvalidParamsError{Context: "CreateIpGroupInput"} 1291 if v.GroupName == nil { 1292 invalidParams.Add(smithy.NewErrParamRequired("GroupName")) 1293 } 1294 if v.Tags != nil { 1295 if err := validateTagList(v.Tags); err != nil { 1296 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1297 } 1298 } 1299 if invalidParams.Len() > 0 { 1300 return invalidParams 1301 } else { 1302 return nil 1303 } 1304} 1305 1306func validateOpCreateTagsInput(v *CreateTagsInput) error { 1307 if v == nil { 1308 return nil 1309 } 1310 invalidParams := smithy.InvalidParamsError{Context: "CreateTagsInput"} 1311 if v.ResourceId == nil { 1312 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1313 } 1314 if v.Tags == nil { 1315 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1316 } else if v.Tags != nil { 1317 if err := validateTagList(v.Tags); err != nil { 1318 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1319 } 1320 } 1321 if invalidParams.Len() > 0 { 1322 return invalidParams 1323 } else { 1324 return nil 1325 } 1326} 1327 1328func validateOpCreateWorkspaceBundleInput(v *CreateWorkspaceBundleInput) error { 1329 if v == nil { 1330 return nil 1331 } 1332 invalidParams := smithy.InvalidParamsError{Context: "CreateWorkspaceBundleInput"} 1333 if v.BundleName == nil { 1334 invalidParams.Add(smithy.NewErrParamRequired("BundleName")) 1335 } 1336 if v.BundleDescription == nil { 1337 invalidParams.Add(smithy.NewErrParamRequired("BundleDescription")) 1338 } 1339 if v.ImageId == nil { 1340 invalidParams.Add(smithy.NewErrParamRequired("ImageId")) 1341 } 1342 if v.ComputeType == nil { 1343 invalidParams.Add(smithy.NewErrParamRequired("ComputeType")) 1344 } 1345 if v.UserStorage == nil { 1346 invalidParams.Add(smithy.NewErrParamRequired("UserStorage")) 1347 } 1348 if v.Tags != nil { 1349 if err := validateTagList(v.Tags); err != nil { 1350 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1351 } 1352 } 1353 if invalidParams.Len() > 0 { 1354 return invalidParams 1355 } else { 1356 return nil 1357 } 1358} 1359 1360func validateOpCreateWorkspacesInput(v *CreateWorkspacesInput) error { 1361 if v == nil { 1362 return nil 1363 } 1364 invalidParams := smithy.InvalidParamsError{Context: "CreateWorkspacesInput"} 1365 if v.Workspaces == nil { 1366 invalidParams.Add(smithy.NewErrParamRequired("Workspaces")) 1367 } else if v.Workspaces != nil { 1368 if err := validateWorkspaceRequestList(v.Workspaces); err != nil { 1369 invalidParams.AddNested("Workspaces", err.(smithy.InvalidParamsError)) 1370 } 1371 } 1372 if invalidParams.Len() > 0 { 1373 return invalidParams 1374 } else { 1375 return nil 1376 } 1377} 1378 1379func validateOpDeleteConnectionAliasInput(v *DeleteConnectionAliasInput) error { 1380 if v == nil { 1381 return nil 1382 } 1383 invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionAliasInput"} 1384 if v.AliasId == nil { 1385 invalidParams.Add(smithy.NewErrParamRequired("AliasId")) 1386 } 1387 if invalidParams.Len() > 0 { 1388 return invalidParams 1389 } else { 1390 return nil 1391 } 1392} 1393 1394func validateOpDeleteIpGroupInput(v *DeleteIpGroupInput) error { 1395 if v == nil { 1396 return nil 1397 } 1398 invalidParams := smithy.InvalidParamsError{Context: "DeleteIpGroupInput"} 1399 if v.GroupId == nil { 1400 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 1401 } 1402 if invalidParams.Len() > 0 { 1403 return invalidParams 1404 } else { 1405 return nil 1406 } 1407} 1408 1409func validateOpDeleteTagsInput(v *DeleteTagsInput) error { 1410 if v == nil { 1411 return nil 1412 } 1413 invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsInput"} 1414 if v.ResourceId == nil { 1415 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1416 } 1417 if v.TagKeys == nil { 1418 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1419 } 1420 if invalidParams.Len() > 0 { 1421 return invalidParams 1422 } else { 1423 return nil 1424 } 1425} 1426 1427func validateOpDeleteWorkspaceImageInput(v *DeleteWorkspaceImageInput) error { 1428 if v == nil { 1429 return nil 1430 } 1431 invalidParams := smithy.InvalidParamsError{Context: "DeleteWorkspaceImageInput"} 1432 if v.ImageId == nil { 1433 invalidParams.Add(smithy.NewErrParamRequired("ImageId")) 1434 } 1435 if invalidParams.Len() > 0 { 1436 return invalidParams 1437 } else { 1438 return nil 1439 } 1440} 1441 1442func validateOpDeregisterWorkspaceDirectoryInput(v *DeregisterWorkspaceDirectoryInput) error { 1443 if v == nil { 1444 return nil 1445 } 1446 invalidParams := smithy.InvalidParamsError{Context: "DeregisterWorkspaceDirectoryInput"} 1447 if v.DirectoryId == nil { 1448 invalidParams.Add(smithy.NewErrParamRequired("DirectoryId")) 1449 } 1450 if invalidParams.Len() > 0 { 1451 return invalidParams 1452 } else { 1453 return nil 1454 } 1455} 1456 1457func validateOpDescribeClientPropertiesInput(v *DescribeClientPropertiesInput) error { 1458 if v == nil { 1459 return nil 1460 } 1461 invalidParams := smithy.InvalidParamsError{Context: "DescribeClientPropertiesInput"} 1462 if v.ResourceIds == nil { 1463 invalidParams.Add(smithy.NewErrParamRequired("ResourceIds")) 1464 } 1465 if invalidParams.Len() > 0 { 1466 return invalidParams 1467 } else { 1468 return nil 1469 } 1470} 1471 1472func validateOpDescribeConnectionAliasPermissionsInput(v *DescribeConnectionAliasPermissionsInput) error { 1473 if v == nil { 1474 return nil 1475 } 1476 invalidParams := smithy.InvalidParamsError{Context: "DescribeConnectionAliasPermissionsInput"} 1477 if v.AliasId == nil { 1478 invalidParams.Add(smithy.NewErrParamRequired("AliasId")) 1479 } 1480 if invalidParams.Len() > 0 { 1481 return invalidParams 1482 } else { 1483 return nil 1484 } 1485} 1486 1487func validateOpDescribeTagsInput(v *DescribeTagsInput) error { 1488 if v == nil { 1489 return nil 1490 } 1491 invalidParams := smithy.InvalidParamsError{Context: "DescribeTagsInput"} 1492 if v.ResourceId == nil { 1493 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1494 } 1495 if invalidParams.Len() > 0 { 1496 return invalidParams 1497 } else { 1498 return nil 1499 } 1500} 1501 1502func validateOpDescribeWorkspaceImagePermissionsInput(v *DescribeWorkspaceImagePermissionsInput) error { 1503 if v == nil { 1504 return nil 1505 } 1506 invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkspaceImagePermissionsInput"} 1507 if v.ImageId == nil { 1508 invalidParams.Add(smithy.NewErrParamRequired("ImageId")) 1509 } 1510 if invalidParams.Len() > 0 { 1511 return invalidParams 1512 } else { 1513 return nil 1514 } 1515} 1516 1517func validateOpDescribeWorkspaceSnapshotsInput(v *DescribeWorkspaceSnapshotsInput) error { 1518 if v == nil { 1519 return nil 1520 } 1521 invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkspaceSnapshotsInput"} 1522 if v.WorkspaceId == nil { 1523 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId")) 1524 } 1525 if invalidParams.Len() > 0 { 1526 return invalidParams 1527 } else { 1528 return nil 1529 } 1530} 1531 1532func validateOpDisassociateConnectionAliasInput(v *DisassociateConnectionAliasInput) error { 1533 if v == nil { 1534 return nil 1535 } 1536 invalidParams := smithy.InvalidParamsError{Context: "DisassociateConnectionAliasInput"} 1537 if v.AliasId == nil { 1538 invalidParams.Add(smithy.NewErrParamRequired("AliasId")) 1539 } 1540 if invalidParams.Len() > 0 { 1541 return invalidParams 1542 } else { 1543 return nil 1544 } 1545} 1546 1547func validateOpDisassociateIpGroupsInput(v *DisassociateIpGroupsInput) error { 1548 if v == nil { 1549 return nil 1550 } 1551 invalidParams := smithy.InvalidParamsError{Context: "DisassociateIpGroupsInput"} 1552 if v.DirectoryId == nil { 1553 invalidParams.Add(smithy.NewErrParamRequired("DirectoryId")) 1554 } 1555 if v.GroupIds == nil { 1556 invalidParams.Add(smithy.NewErrParamRequired("GroupIds")) 1557 } 1558 if invalidParams.Len() > 0 { 1559 return invalidParams 1560 } else { 1561 return nil 1562 } 1563} 1564 1565func validateOpImportWorkspaceImageInput(v *ImportWorkspaceImageInput) error { 1566 if v == nil { 1567 return nil 1568 } 1569 invalidParams := smithy.InvalidParamsError{Context: "ImportWorkspaceImageInput"} 1570 if v.Ec2ImageId == nil { 1571 invalidParams.Add(smithy.NewErrParamRequired("Ec2ImageId")) 1572 } 1573 if len(v.IngestionProcess) == 0 { 1574 invalidParams.Add(smithy.NewErrParamRequired("IngestionProcess")) 1575 } 1576 if v.ImageName == nil { 1577 invalidParams.Add(smithy.NewErrParamRequired("ImageName")) 1578 } 1579 if v.ImageDescription == nil { 1580 invalidParams.Add(smithy.NewErrParamRequired("ImageDescription")) 1581 } 1582 if v.Tags != nil { 1583 if err := validateTagList(v.Tags); err != nil { 1584 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1585 } 1586 } 1587 if invalidParams.Len() > 0 { 1588 return invalidParams 1589 } else { 1590 return nil 1591 } 1592} 1593 1594func validateOpListAvailableManagementCidrRangesInput(v *ListAvailableManagementCidrRangesInput) error { 1595 if v == nil { 1596 return nil 1597 } 1598 invalidParams := smithy.InvalidParamsError{Context: "ListAvailableManagementCidrRangesInput"} 1599 if v.ManagementCidrRangeConstraint == nil { 1600 invalidParams.Add(smithy.NewErrParamRequired("ManagementCidrRangeConstraint")) 1601 } 1602 if invalidParams.Len() > 0 { 1603 return invalidParams 1604 } else { 1605 return nil 1606 } 1607} 1608 1609func validateOpMigrateWorkspaceInput(v *MigrateWorkspaceInput) error { 1610 if v == nil { 1611 return nil 1612 } 1613 invalidParams := smithy.InvalidParamsError{Context: "MigrateWorkspaceInput"} 1614 if v.SourceWorkspaceId == nil { 1615 invalidParams.Add(smithy.NewErrParamRequired("SourceWorkspaceId")) 1616 } 1617 if v.BundleId == nil { 1618 invalidParams.Add(smithy.NewErrParamRequired("BundleId")) 1619 } 1620 if invalidParams.Len() > 0 { 1621 return invalidParams 1622 } else { 1623 return nil 1624 } 1625} 1626 1627func validateOpModifyClientPropertiesInput(v *ModifyClientPropertiesInput) error { 1628 if v == nil { 1629 return nil 1630 } 1631 invalidParams := smithy.InvalidParamsError{Context: "ModifyClientPropertiesInput"} 1632 if v.ResourceId == nil { 1633 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1634 } 1635 if v.ClientProperties == nil { 1636 invalidParams.Add(smithy.NewErrParamRequired("ClientProperties")) 1637 } 1638 if invalidParams.Len() > 0 { 1639 return invalidParams 1640 } else { 1641 return nil 1642 } 1643} 1644 1645func validateOpModifySelfservicePermissionsInput(v *ModifySelfservicePermissionsInput) error { 1646 if v == nil { 1647 return nil 1648 } 1649 invalidParams := smithy.InvalidParamsError{Context: "ModifySelfservicePermissionsInput"} 1650 if v.ResourceId == nil { 1651 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1652 } 1653 if v.SelfservicePermissions == nil { 1654 invalidParams.Add(smithy.NewErrParamRequired("SelfservicePermissions")) 1655 } 1656 if invalidParams.Len() > 0 { 1657 return invalidParams 1658 } else { 1659 return nil 1660 } 1661} 1662 1663func validateOpModifyWorkspaceAccessPropertiesInput(v *ModifyWorkspaceAccessPropertiesInput) error { 1664 if v == nil { 1665 return nil 1666 } 1667 invalidParams := smithy.InvalidParamsError{Context: "ModifyWorkspaceAccessPropertiesInput"} 1668 if v.ResourceId == nil { 1669 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1670 } 1671 if v.WorkspaceAccessProperties == nil { 1672 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceAccessProperties")) 1673 } 1674 if invalidParams.Len() > 0 { 1675 return invalidParams 1676 } else { 1677 return nil 1678 } 1679} 1680 1681func validateOpModifyWorkspaceCreationPropertiesInput(v *ModifyWorkspaceCreationPropertiesInput) error { 1682 if v == nil { 1683 return nil 1684 } 1685 invalidParams := smithy.InvalidParamsError{Context: "ModifyWorkspaceCreationPropertiesInput"} 1686 if v.ResourceId == nil { 1687 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1688 } 1689 if v.WorkspaceCreationProperties == nil { 1690 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceCreationProperties")) 1691 } 1692 if invalidParams.Len() > 0 { 1693 return invalidParams 1694 } else { 1695 return nil 1696 } 1697} 1698 1699func validateOpModifyWorkspacePropertiesInput(v *ModifyWorkspacePropertiesInput) error { 1700 if v == nil { 1701 return nil 1702 } 1703 invalidParams := smithy.InvalidParamsError{Context: "ModifyWorkspacePropertiesInput"} 1704 if v.WorkspaceId == nil { 1705 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId")) 1706 } 1707 if v.WorkspaceProperties == nil { 1708 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceProperties")) 1709 } 1710 if invalidParams.Len() > 0 { 1711 return invalidParams 1712 } else { 1713 return nil 1714 } 1715} 1716 1717func validateOpModifyWorkspaceStateInput(v *ModifyWorkspaceStateInput) error { 1718 if v == nil { 1719 return nil 1720 } 1721 invalidParams := smithy.InvalidParamsError{Context: "ModifyWorkspaceStateInput"} 1722 if v.WorkspaceId == nil { 1723 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId")) 1724 } 1725 if len(v.WorkspaceState) == 0 { 1726 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceState")) 1727 } 1728 if invalidParams.Len() > 0 { 1729 return invalidParams 1730 } else { 1731 return nil 1732 } 1733} 1734 1735func validateOpRebootWorkspacesInput(v *RebootWorkspacesInput) error { 1736 if v == nil { 1737 return nil 1738 } 1739 invalidParams := smithy.InvalidParamsError{Context: "RebootWorkspacesInput"} 1740 if v.RebootWorkspaceRequests == nil { 1741 invalidParams.Add(smithy.NewErrParamRequired("RebootWorkspaceRequests")) 1742 } else if v.RebootWorkspaceRequests != nil { 1743 if err := validateRebootWorkspaceRequests(v.RebootWorkspaceRequests); err != nil { 1744 invalidParams.AddNested("RebootWorkspaceRequests", err.(smithy.InvalidParamsError)) 1745 } 1746 } 1747 if invalidParams.Len() > 0 { 1748 return invalidParams 1749 } else { 1750 return nil 1751 } 1752} 1753 1754func validateOpRebuildWorkspacesInput(v *RebuildWorkspacesInput) error { 1755 if v == nil { 1756 return nil 1757 } 1758 invalidParams := smithy.InvalidParamsError{Context: "RebuildWorkspacesInput"} 1759 if v.RebuildWorkspaceRequests == nil { 1760 invalidParams.Add(smithy.NewErrParamRequired("RebuildWorkspaceRequests")) 1761 } else if v.RebuildWorkspaceRequests != nil { 1762 if err := validateRebuildWorkspaceRequests(v.RebuildWorkspaceRequests); err != nil { 1763 invalidParams.AddNested("RebuildWorkspaceRequests", err.(smithy.InvalidParamsError)) 1764 } 1765 } 1766 if invalidParams.Len() > 0 { 1767 return invalidParams 1768 } else { 1769 return nil 1770 } 1771} 1772 1773func validateOpRegisterWorkspaceDirectoryInput(v *RegisterWorkspaceDirectoryInput) error { 1774 if v == nil { 1775 return nil 1776 } 1777 invalidParams := smithy.InvalidParamsError{Context: "RegisterWorkspaceDirectoryInput"} 1778 if v.DirectoryId == nil { 1779 invalidParams.Add(smithy.NewErrParamRequired("DirectoryId")) 1780 } 1781 if v.EnableWorkDocs == nil { 1782 invalidParams.Add(smithy.NewErrParamRequired("EnableWorkDocs")) 1783 } 1784 if v.Tags != nil { 1785 if err := validateTagList(v.Tags); err != nil { 1786 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1787 } 1788 } 1789 if invalidParams.Len() > 0 { 1790 return invalidParams 1791 } else { 1792 return nil 1793 } 1794} 1795 1796func validateOpRestoreWorkspaceInput(v *RestoreWorkspaceInput) error { 1797 if v == nil { 1798 return nil 1799 } 1800 invalidParams := smithy.InvalidParamsError{Context: "RestoreWorkspaceInput"} 1801 if v.WorkspaceId == nil { 1802 invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId")) 1803 } 1804 if invalidParams.Len() > 0 { 1805 return invalidParams 1806 } else { 1807 return nil 1808 } 1809} 1810 1811func validateOpRevokeIpRulesInput(v *RevokeIpRulesInput) error { 1812 if v == nil { 1813 return nil 1814 } 1815 invalidParams := smithy.InvalidParamsError{Context: "RevokeIpRulesInput"} 1816 if v.GroupId == nil { 1817 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 1818 } 1819 if v.UserRules == nil { 1820 invalidParams.Add(smithy.NewErrParamRequired("UserRules")) 1821 } 1822 if invalidParams.Len() > 0 { 1823 return invalidParams 1824 } else { 1825 return nil 1826 } 1827} 1828 1829func validateOpStartWorkspacesInput(v *StartWorkspacesInput) error { 1830 if v == nil { 1831 return nil 1832 } 1833 invalidParams := smithy.InvalidParamsError{Context: "StartWorkspacesInput"} 1834 if v.StartWorkspaceRequests == nil { 1835 invalidParams.Add(smithy.NewErrParamRequired("StartWorkspaceRequests")) 1836 } 1837 if invalidParams.Len() > 0 { 1838 return invalidParams 1839 } else { 1840 return nil 1841 } 1842} 1843 1844func validateOpStopWorkspacesInput(v *StopWorkspacesInput) error { 1845 if v == nil { 1846 return nil 1847 } 1848 invalidParams := smithy.InvalidParamsError{Context: "StopWorkspacesInput"} 1849 if v.StopWorkspaceRequests == nil { 1850 invalidParams.Add(smithy.NewErrParamRequired("StopWorkspaceRequests")) 1851 } 1852 if invalidParams.Len() > 0 { 1853 return invalidParams 1854 } else { 1855 return nil 1856 } 1857} 1858 1859func validateOpTerminateWorkspacesInput(v *TerminateWorkspacesInput) error { 1860 if v == nil { 1861 return nil 1862 } 1863 invalidParams := smithy.InvalidParamsError{Context: "TerminateWorkspacesInput"} 1864 if v.TerminateWorkspaceRequests == nil { 1865 invalidParams.Add(smithy.NewErrParamRequired("TerminateWorkspaceRequests")) 1866 } else if v.TerminateWorkspaceRequests != nil { 1867 if err := validateTerminateWorkspaceRequests(v.TerminateWorkspaceRequests); err != nil { 1868 invalidParams.AddNested("TerminateWorkspaceRequests", err.(smithy.InvalidParamsError)) 1869 } 1870 } 1871 if invalidParams.Len() > 0 { 1872 return invalidParams 1873 } else { 1874 return nil 1875 } 1876} 1877 1878func validateOpUpdateConnectionAliasPermissionInput(v *UpdateConnectionAliasPermissionInput) error { 1879 if v == nil { 1880 return nil 1881 } 1882 invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionAliasPermissionInput"} 1883 if v.AliasId == nil { 1884 invalidParams.Add(smithy.NewErrParamRequired("AliasId")) 1885 } 1886 if v.ConnectionAliasPermission == nil { 1887 invalidParams.Add(smithy.NewErrParamRequired("ConnectionAliasPermission")) 1888 } else if v.ConnectionAliasPermission != nil { 1889 if err := validateConnectionAliasPermission(v.ConnectionAliasPermission); err != nil { 1890 invalidParams.AddNested("ConnectionAliasPermission", err.(smithy.InvalidParamsError)) 1891 } 1892 } 1893 if invalidParams.Len() > 0 { 1894 return invalidParams 1895 } else { 1896 return nil 1897 } 1898} 1899 1900func validateOpUpdateRulesOfIpGroupInput(v *UpdateRulesOfIpGroupInput) error { 1901 if v == nil { 1902 return nil 1903 } 1904 invalidParams := smithy.InvalidParamsError{Context: "UpdateRulesOfIpGroupInput"} 1905 if v.GroupId == nil { 1906 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 1907 } 1908 if v.UserRules == nil { 1909 invalidParams.Add(smithy.NewErrParamRequired("UserRules")) 1910 } 1911 if invalidParams.Len() > 0 { 1912 return invalidParams 1913 } else { 1914 return nil 1915 } 1916} 1917 1918func validateOpUpdateWorkspaceImagePermissionInput(v *UpdateWorkspaceImagePermissionInput) error { 1919 if v == nil { 1920 return nil 1921 } 1922 invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkspaceImagePermissionInput"} 1923 if v.ImageId == nil { 1924 invalidParams.Add(smithy.NewErrParamRequired("ImageId")) 1925 } 1926 if v.AllowCopyImage == nil { 1927 invalidParams.Add(smithy.NewErrParamRequired("AllowCopyImage")) 1928 } 1929 if v.SharedAccountId == nil { 1930 invalidParams.Add(smithy.NewErrParamRequired("SharedAccountId")) 1931 } 1932 if invalidParams.Len() > 0 { 1933 return invalidParams 1934 } else { 1935 return nil 1936 } 1937} 1938