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