1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package appstream 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/appstream/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAssociateFleet struct { 14} 15 16func (*validateOpAssociateFleet) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAssociateFleet) 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.(*AssociateFleetInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAssociateFleetInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpBatchAssociateUserStack struct { 34} 35 36func (*validateOpBatchAssociateUserStack) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpBatchAssociateUserStack) 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.(*BatchAssociateUserStackInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpBatchAssociateUserStackInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpBatchDisassociateUserStack struct { 54} 55 56func (*validateOpBatchDisassociateUserStack) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpBatchDisassociateUserStack) 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.(*BatchDisassociateUserStackInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpBatchDisassociateUserStackInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCopyImage struct { 74} 75 76func (*validateOpCopyImage) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCopyImage) 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.(*CopyImageInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCopyImageInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateDirectoryConfig struct { 94} 95 96func (*validateOpCreateDirectoryConfig) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateDirectoryConfig) 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.(*CreateDirectoryConfigInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateDirectoryConfigInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateFleet struct { 114} 115 116func (*validateOpCreateFleet) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateFleet) 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.(*CreateFleetInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateFleetInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateImageBuilder struct { 134} 135 136func (*validateOpCreateImageBuilder) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateImageBuilder) 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.(*CreateImageBuilderInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateImageBuilderInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreateImageBuilderStreamingURL struct { 154} 155 156func (*validateOpCreateImageBuilderStreamingURL) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreateImageBuilderStreamingURL) 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.(*CreateImageBuilderStreamingURLInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreateImageBuilderStreamingURLInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpCreateStack struct { 174} 175 176func (*validateOpCreateStack) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpCreateStack) 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.(*CreateStackInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpCreateStackInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpCreateStreamingURL struct { 194} 195 196func (*validateOpCreateStreamingURL) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpCreateStreamingURL) 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.(*CreateStreamingURLInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpCreateStreamingURLInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpCreateUpdatedImage struct { 214} 215 216func (*validateOpCreateUpdatedImage) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpCreateUpdatedImage) 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.(*CreateUpdatedImageInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpCreateUpdatedImageInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpCreateUser struct { 234} 235 236func (*validateOpCreateUser) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpCreateUser) 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.(*CreateUserInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpCreateUserInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteDirectoryConfig struct { 254} 255 256func (*validateOpDeleteDirectoryConfig) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteDirectoryConfig) 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.(*DeleteDirectoryConfigInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteDirectoryConfigInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeleteFleet struct { 274} 275 276func (*validateOpDeleteFleet) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeleteFleet) 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.(*DeleteFleetInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeleteFleetInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDeleteImageBuilder struct { 294} 295 296func (*validateOpDeleteImageBuilder) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDeleteImageBuilder) 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.(*DeleteImageBuilderInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDeleteImageBuilderInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDeleteImage struct { 314} 315 316func (*validateOpDeleteImage) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDeleteImage) 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.(*DeleteImageInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDeleteImageInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDeleteImagePermissions struct { 334} 335 336func (*validateOpDeleteImagePermissions) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDeleteImagePermissions) 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.(*DeleteImagePermissionsInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDeleteImagePermissionsInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDeleteStack struct { 354} 355 356func (*validateOpDeleteStack) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDeleteStack) 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.(*DeleteStackInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDeleteStackInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDeleteUser struct { 374} 375 376func (*validateOpDeleteUser) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDeleteUser) 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.(*DeleteUserInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDeleteUserInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribeImagePermissions struct { 394} 395 396func (*validateOpDescribeImagePermissions) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribeImagePermissions) 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.(*DescribeImagePermissionsInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribeImagePermissionsInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDescribeSessions struct { 414} 415 416func (*validateOpDescribeSessions) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDescribeSessions) 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.(*DescribeSessionsInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDescribeSessionsInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDescribeUsers struct { 434} 435 436func (*validateOpDescribeUsers) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDescribeUsers) 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.(*DescribeUsersInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDescribeUsersInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDisableUser struct { 454} 455 456func (*validateOpDisableUser) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDisableUser) 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.(*DisableUserInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDisableUserInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpDisassociateFleet struct { 474} 475 476func (*validateOpDisassociateFleet) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpDisassociateFleet) 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.(*DisassociateFleetInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpDisassociateFleetInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpEnableUser struct { 494} 495 496func (*validateOpEnableUser) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpEnableUser) 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.(*EnableUserInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpEnableUserInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpExpireSession struct { 514} 515 516func (*validateOpExpireSession) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpExpireSession) 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.(*ExpireSessionInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpExpireSessionInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpListAssociatedFleets struct { 534} 535 536func (*validateOpListAssociatedFleets) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpListAssociatedFleets) 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.(*ListAssociatedFleetsInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpListAssociatedFleetsInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpListAssociatedStacks struct { 554} 555 556func (*validateOpListAssociatedStacks) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpListAssociatedStacks) 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.(*ListAssociatedStacksInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpListAssociatedStacksInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpListTagsForResource struct { 574} 575 576func (*validateOpListTagsForResource) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpListTagsForResourceInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpStartFleet struct { 594} 595 596func (*validateOpStartFleet) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpStartFleet) 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.(*StartFleetInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpStartFleetInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpStartImageBuilder struct { 614} 615 616func (*validateOpStartImageBuilder) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpStartImageBuilder) 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.(*StartImageBuilderInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpStartImageBuilderInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpStopFleet struct { 634} 635 636func (*validateOpStopFleet) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpStopFleet) 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.(*StopFleetInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpStopFleetInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpStopImageBuilder struct { 654} 655 656func (*validateOpStopImageBuilder) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpStopImageBuilder) 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.(*StopImageBuilderInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpStopImageBuilderInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpTagResource struct { 674} 675 676func (*validateOpTagResource) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpTagResource) 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.(*TagResourceInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpTagResourceInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpUntagResource struct { 694} 695 696func (*validateOpUntagResource) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpUntagResource) 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.(*UntagResourceInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpUntagResourceInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpUpdateDirectoryConfig struct { 714} 715 716func (*validateOpUpdateDirectoryConfig) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpUpdateDirectoryConfig) 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.(*UpdateDirectoryConfigInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpUpdateDirectoryConfigInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpUpdateFleet struct { 734} 735 736func (*validateOpUpdateFleet) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpUpdateFleet) 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.(*UpdateFleetInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpUpdateFleetInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpUpdateImagePermissions struct { 754} 755 756func (*validateOpUpdateImagePermissions) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpUpdateImagePermissions) 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.(*UpdateImagePermissionsInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpUpdateImagePermissionsInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpUpdateStack struct { 774} 775 776func (*validateOpUpdateStack) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpUpdateStack) 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.(*UpdateStackInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpUpdateStackInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793func addOpAssociateFleetValidationMiddleware(stack *middleware.Stack) error { 794 return stack.Initialize.Add(&validateOpAssociateFleet{}, middleware.After) 795} 796 797func addOpBatchAssociateUserStackValidationMiddleware(stack *middleware.Stack) error { 798 return stack.Initialize.Add(&validateOpBatchAssociateUserStack{}, middleware.After) 799} 800 801func addOpBatchDisassociateUserStackValidationMiddleware(stack *middleware.Stack) error { 802 return stack.Initialize.Add(&validateOpBatchDisassociateUserStack{}, middleware.After) 803} 804 805func addOpCopyImageValidationMiddleware(stack *middleware.Stack) error { 806 return stack.Initialize.Add(&validateOpCopyImage{}, middleware.After) 807} 808 809func addOpCreateDirectoryConfigValidationMiddleware(stack *middleware.Stack) error { 810 return stack.Initialize.Add(&validateOpCreateDirectoryConfig{}, middleware.After) 811} 812 813func addOpCreateFleetValidationMiddleware(stack *middleware.Stack) error { 814 return stack.Initialize.Add(&validateOpCreateFleet{}, middleware.After) 815} 816 817func addOpCreateImageBuilderValidationMiddleware(stack *middleware.Stack) error { 818 return stack.Initialize.Add(&validateOpCreateImageBuilder{}, middleware.After) 819} 820 821func addOpCreateImageBuilderStreamingURLValidationMiddleware(stack *middleware.Stack) error { 822 return stack.Initialize.Add(&validateOpCreateImageBuilderStreamingURL{}, middleware.After) 823} 824 825func addOpCreateStackValidationMiddleware(stack *middleware.Stack) error { 826 return stack.Initialize.Add(&validateOpCreateStack{}, middleware.After) 827} 828 829func addOpCreateStreamingURLValidationMiddleware(stack *middleware.Stack) error { 830 return stack.Initialize.Add(&validateOpCreateStreamingURL{}, middleware.After) 831} 832 833func addOpCreateUpdatedImageValidationMiddleware(stack *middleware.Stack) error { 834 return stack.Initialize.Add(&validateOpCreateUpdatedImage{}, middleware.After) 835} 836 837func addOpCreateUserValidationMiddleware(stack *middleware.Stack) error { 838 return stack.Initialize.Add(&validateOpCreateUser{}, middleware.After) 839} 840 841func addOpDeleteDirectoryConfigValidationMiddleware(stack *middleware.Stack) error { 842 return stack.Initialize.Add(&validateOpDeleteDirectoryConfig{}, middleware.After) 843} 844 845func addOpDeleteFleetValidationMiddleware(stack *middleware.Stack) error { 846 return stack.Initialize.Add(&validateOpDeleteFleet{}, middleware.After) 847} 848 849func addOpDeleteImageBuilderValidationMiddleware(stack *middleware.Stack) error { 850 return stack.Initialize.Add(&validateOpDeleteImageBuilder{}, middleware.After) 851} 852 853func addOpDeleteImageValidationMiddleware(stack *middleware.Stack) error { 854 return stack.Initialize.Add(&validateOpDeleteImage{}, middleware.After) 855} 856 857func addOpDeleteImagePermissionsValidationMiddleware(stack *middleware.Stack) error { 858 return stack.Initialize.Add(&validateOpDeleteImagePermissions{}, middleware.After) 859} 860 861func addOpDeleteStackValidationMiddleware(stack *middleware.Stack) error { 862 return stack.Initialize.Add(&validateOpDeleteStack{}, middleware.After) 863} 864 865func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error { 866 return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After) 867} 868 869func addOpDescribeImagePermissionsValidationMiddleware(stack *middleware.Stack) error { 870 return stack.Initialize.Add(&validateOpDescribeImagePermissions{}, middleware.After) 871} 872 873func addOpDescribeSessionsValidationMiddleware(stack *middleware.Stack) error { 874 return stack.Initialize.Add(&validateOpDescribeSessions{}, middleware.After) 875} 876 877func addOpDescribeUsersValidationMiddleware(stack *middleware.Stack) error { 878 return stack.Initialize.Add(&validateOpDescribeUsers{}, middleware.After) 879} 880 881func addOpDisableUserValidationMiddleware(stack *middleware.Stack) error { 882 return stack.Initialize.Add(&validateOpDisableUser{}, middleware.After) 883} 884 885func addOpDisassociateFleetValidationMiddleware(stack *middleware.Stack) error { 886 return stack.Initialize.Add(&validateOpDisassociateFleet{}, middleware.After) 887} 888 889func addOpEnableUserValidationMiddleware(stack *middleware.Stack) error { 890 return stack.Initialize.Add(&validateOpEnableUser{}, middleware.After) 891} 892 893func addOpExpireSessionValidationMiddleware(stack *middleware.Stack) error { 894 return stack.Initialize.Add(&validateOpExpireSession{}, middleware.After) 895} 896 897func addOpListAssociatedFleetsValidationMiddleware(stack *middleware.Stack) error { 898 return stack.Initialize.Add(&validateOpListAssociatedFleets{}, middleware.After) 899} 900 901func addOpListAssociatedStacksValidationMiddleware(stack *middleware.Stack) error { 902 return stack.Initialize.Add(&validateOpListAssociatedStacks{}, middleware.After) 903} 904 905func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 906 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 907} 908 909func addOpStartFleetValidationMiddleware(stack *middleware.Stack) error { 910 return stack.Initialize.Add(&validateOpStartFleet{}, middleware.After) 911} 912 913func addOpStartImageBuilderValidationMiddleware(stack *middleware.Stack) error { 914 return stack.Initialize.Add(&validateOpStartImageBuilder{}, middleware.After) 915} 916 917func addOpStopFleetValidationMiddleware(stack *middleware.Stack) error { 918 return stack.Initialize.Add(&validateOpStopFleet{}, middleware.After) 919} 920 921func addOpStopImageBuilderValidationMiddleware(stack *middleware.Stack) error { 922 return stack.Initialize.Add(&validateOpStopImageBuilder{}, middleware.After) 923} 924 925func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 926 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 927} 928 929func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 930 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 931} 932 933func addOpUpdateDirectoryConfigValidationMiddleware(stack *middleware.Stack) error { 934 return stack.Initialize.Add(&validateOpUpdateDirectoryConfig{}, middleware.After) 935} 936 937func addOpUpdateFleetValidationMiddleware(stack *middleware.Stack) error { 938 return stack.Initialize.Add(&validateOpUpdateFleet{}, middleware.After) 939} 940 941func addOpUpdateImagePermissionsValidationMiddleware(stack *middleware.Stack) error { 942 return stack.Initialize.Add(&validateOpUpdateImagePermissions{}, middleware.After) 943} 944 945func addOpUpdateStackValidationMiddleware(stack *middleware.Stack) error { 946 return stack.Initialize.Add(&validateOpUpdateStack{}, middleware.After) 947} 948 949func validateAccessEndpoint(v *types.AccessEndpoint) error { 950 if v == nil { 951 return nil 952 } 953 invalidParams := smithy.InvalidParamsError{Context: "AccessEndpoint"} 954 if len(v.EndpointType) == 0 { 955 invalidParams.Add(smithy.NewErrParamRequired("EndpointType")) 956 } 957 if invalidParams.Len() > 0 { 958 return invalidParams 959 } else { 960 return nil 961 } 962} 963 964func validateAccessEndpointList(v []types.AccessEndpoint) error { 965 if v == nil { 966 return nil 967 } 968 invalidParams := smithy.InvalidParamsError{Context: "AccessEndpointList"} 969 for i := range v { 970 if err := validateAccessEndpoint(&v[i]); err != nil { 971 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 972 } 973 } 974 if invalidParams.Len() > 0 { 975 return invalidParams 976 } else { 977 return nil 978 } 979} 980 981func validateApplicationSettings(v *types.ApplicationSettings) error { 982 if v == nil { 983 return nil 984 } 985 invalidParams := smithy.InvalidParamsError{Context: "ApplicationSettings"} 986 if invalidParams.Len() > 0 { 987 return invalidParams 988 } else { 989 return nil 990 } 991} 992 993func validateComputeCapacity(v *types.ComputeCapacity) error { 994 if v == nil { 995 return nil 996 } 997 invalidParams := smithy.InvalidParamsError{Context: "ComputeCapacity"} 998 if v.DesiredInstances == nil { 999 invalidParams.Add(smithy.NewErrParamRequired("DesiredInstances")) 1000 } 1001 if invalidParams.Len() > 0 { 1002 return invalidParams 1003 } else { 1004 return nil 1005 } 1006} 1007 1008func validateServiceAccountCredentials(v *types.ServiceAccountCredentials) error { 1009 if v == nil { 1010 return nil 1011 } 1012 invalidParams := smithy.InvalidParamsError{Context: "ServiceAccountCredentials"} 1013 if v.AccountName == nil { 1014 invalidParams.Add(smithy.NewErrParamRequired("AccountName")) 1015 } 1016 if v.AccountPassword == nil { 1017 invalidParams.Add(smithy.NewErrParamRequired("AccountPassword")) 1018 } 1019 if invalidParams.Len() > 0 { 1020 return invalidParams 1021 } else { 1022 return nil 1023 } 1024} 1025 1026func validateStorageConnector(v *types.StorageConnector) error { 1027 if v == nil { 1028 return nil 1029 } 1030 invalidParams := smithy.InvalidParamsError{Context: "StorageConnector"} 1031 if len(v.ConnectorType) == 0 { 1032 invalidParams.Add(smithy.NewErrParamRequired("ConnectorType")) 1033 } 1034 if invalidParams.Len() > 0 { 1035 return invalidParams 1036 } else { 1037 return nil 1038 } 1039} 1040 1041func validateStorageConnectorList(v []types.StorageConnector) error { 1042 if v == nil { 1043 return nil 1044 } 1045 invalidParams := smithy.InvalidParamsError{Context: "StorageConnectorList"} 1046 for i := range v { 1047 if err := validateStorageConnector(&v[i]); err != nil { 1048 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1049 } 1050 } 1051 if invalidParams.Len() > 0 { 1052 return invalidParams 1053 } else { 1054 return nil 1055 } 1056} 1057 1058func validateUserSetting(v *types.UserSetting) error { 1059 if v == nil { 1060 return nil 1061 } 1062 invalidParams := smithy.InvalidParamsError{Context: "UserSetting"} 1063 if len(v.Action) == 0 { 1064 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1065 } 1066 if len(v.Permission) == 0 { 1067 invalidParams.Add(smithy.NewErrParamRequired("Permission")) 1068 } 1069 if invalidParams.Len() > 0 { 1070 return invalidParams 1071 } else { 1072 return nil 1073 } 1074} 1075 1076func validateUserSettingList(v []types.UserSetting) error { 1077 if v == nil { 1078 return nil 1079 } 1080 invalidParams := smithy.InvalidParamsError{Context: "UserSettingList"} 1081 for i := range v { 1082 if err := validateUserSetting(&v[i]); err != nil { 1083 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1084 } 1085 } 1086 if invalidParams.Len() > 0 { 1087 return invalidParams 1088 } else { 1089 return nil 1090 } 1091} 1092 1093func validateUserStackAssociation(v *types.UserStackAssociation) error { 1094 if v == nil { 1095 return nil 1096 } 1097 invalidParams := smithy.InvalidParamsError{Context: "UserStackAssociation"} 1098 if v.StackName == nil { 1099 invalidParams.Add(smithy.NewErrParamRequired("StackName")) 1100 } 1101 if v.UserName == nil { 1102 invalidParams.Add(smithy.NewErrParamRequired("UserName")) 1103 } 1104 if len(v.AuthenticationType) == 0 { 1105 invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType")) 1106 } 1107 if invalidParams.Len() > 0 { 1108 return invalidParams 1109 } else { 1110 return nil 1111 } 1112} 1113 1114func validateUserStackAssociationList(v []types.UserStackAssociation) error { 1115 if v == nil { 1116 return nil 1117 } 1118 invalidParams := smithy.InvalidParamsError{Context: "UserStackAssociationList"} 1119 for i := range v { 1120 if err := validateUserStackAssociation(&v[i]); err != nil { 1121 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1122 } 1123 } 1124 if invalidParams.Len() > 0 { 1125 return invalidParams 1126 } else { 1127 return nil 1128 } 1129} 1130 1131func validateOpAssociateFleetInput(v *AssociateFleetInput) error { 1132 if v == nil { 1133 return nil 1134 } 1135 invalidParams := smithy.InvalidParamsError{Context: "AssociateFleetInput"} 1136 if v.FleetName == nil { 1137 invalidParams.Add(smithy.NewErrParamRequired("FleetName")) 1138 } 1139 if v.StackName == nil { 1140 invalidParams.Add(smithy.NewErrParamRequired("StackName")) 1141 } 1142 if invalidParams.Len() > 0 { 1143 return invalidParams 1144 } else { 1145 return nil 1146 } 1147} 1148 1149func validateOpBatchAssociateUserStackInput(v *BatchAssociateUserStackInput) error { 1150 if v == nil { 1151 return nil 1152 } 1153 invalidParams := smithy.InvalidParamsError{Context: "BatchAssociateUserStackInput"} 1154 if v.UserStackAssociations == nil { 1155 invalidParams.Add(smithy.NewErrParamRequired("UserStackAssociations")) 1156 } else if v.UserStackAssociations != nil { 1157 if err := validateUserStackAssociationList(v.UserStackAssociations); err != nil { 1158 invalidParams.AddNested("UserStackAssociations", err.(smithy.InvalidParamsError)) 1159 } 1160 } 1161 if invalidParams.Len() > 0 { 1162 return invalidParams 1163 } else { 1164 return nil 1165 } 1166} 1167 1168func validateOpBatchDisassociateUserStackInput(v *BatchDisassociateUserStackInput) error { 1169 if v == nil { 1170 return nil 1171 } 1172 invalidParams := smithy.InvalidParamsError{Context: "BatchDisassociateUserStackInput"} 1173 if v.UserStackAssociations == nil { 1174 invalidParams.Add(smithy.NewErrParamRequired("UserStackAssociations")) 1175 } else if v.UserStackAssociations != nil { 1176 if err := validateUserStackAssociationList(v.UserStackAssociations); err != nil { 1177 invalidParams.AddNested("UserStackAssociations", err.(smithy.InvalidParamsError)) 1178 } 1179 } 1180 if invalidParams.Len() > 0 { 1181 return invalidParams 1182 } else { 1183 return nil 1184 } 1185} 1186 1187func validateOpCopyImageInput(v *CopyImageInput) error { 1188 if v == nil { 1189 return nil 1190 } 1191 invalidParams := smithy.InvalidParamsError{Context: "CopyImageInput"} 1192 if v.SourceImageName == nil { 1193 invalidParams.Add(smithy.NewErrParamRequired("SourceImageName")) 1194 } 1195 if v.DestinationImageName == nil { 1196 invalidParams.Add(smithy.NewErrParamRequired("DestinationImageName")) 1197 } 1198 if v.DestinationRegion == nil { 1199 invalidParams.Add(smithy.NewErrParamRequired("DestinationRegion")) 1200 } 1201 if invalidParams.Len() > 0 { 1202 return invalidParams 1203 } else { 1204 return nil 1205 } 1206} 1207 1208func validateOpCreateDirectoryConfigInput(v *CreateDirectoryConfigInput) error { 1209 if v == nil { 1210 return nil 1211 } 1212 invalidParams := smithy.InvalidParamsError{Context: "CreateDirectoryConfigInput"} 1213 if v.DirectoryName == nil { 1214 invalidParams.Add(smithy.NewErrParamRequired("DirectoryName")) 1215 } 1216 if v.OrganizationalUnitDistinguishedNames == nil { 1217 invalidParams.Add(smithy.NewErrParamRequired("OrganizationalUnitDistinguishedNames")) 1218 } 1219 if v.ServiceAccountCredentials != nil { 1220 if err := validateServiceAccountCredentials(v.ServiceAccountCredentials); err != nil { 1221 invalidParams.AddNested("ServiceAccountCredentials", err.(smithy.InvalidParamsError)) 1222 } 1223 } 1224 if invalidParams.Len() > 0 { 1225 return invalidParams 1226 } else { 1227 return nil 1228 } 1229} 1230 1231func validateOpCreateFleetInput(v *CreateFleetInput) error { 1232 if v == nil { 1233 return nil 1234 } 1235 invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"} 1236 if v.Name == nil { 1237 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1238 } 1239 if v.InstanceType == nil { 1240 invalidParams.Add(smithy.NewErrParamRequired("InstanceType")) 1241 } 1242 if v.ComputeCapacity == nil { 1243 invalidParams.Add(smithy.NewErrParamRequired("ComputeCapacity")) 1244 } else if v.ComputeCapacity != nil { 1245 if err := validateComputeCapacity(v.ComputeCapacity); err != nil { 1246 invalidParams.AddNested("ComputeCapacity", err.(smithy.InvalidParamsError)) 1247 } 1248 } 1249 if invalidParams.Len() > 0 { 1250 return invalidParams 1251 } else { 1252 return nil 1253 } 1254} 1255 1256func validateOpCreateImageBuilderInput(v *CreateImageBuilderInput) error { 1257 if v == nil { 1258 return nil 1259 } 1260 invalidParams := smithy.InvalidParamsError{Context: "CreateImageBuilderInput"} 1261 if v.Name == nil { 1262 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1263 } 1264 if v.InstanceType == nil { 1265 invalidParams.Add(smithy.NewErrParamRequired("InstanceType")) 1266 } 1267 if v.AccessEndpoints != nil { 1268 if err := validateAccessEndpointList(v.AccessEndpoints); err != nil { 1269 invalidParams.AddNested("AccessEndpoints", err.(smithy.InvalidParamsError)) 1270 } 1271 } 1272 if invalidParams.Len() > 0 { 1273 return invalidParams 1274 } else { 1275 return nil 1276 } 1277} 1278 1279func validateOpCreateImageBuilderStreamingURLInput(v *CreateImageBuilderStreamingURLInput) error { 1280 if v == nil { 1281 return nil 1282 } 1283 invalidParams := smithy.InvalidParamsError{Context: "CreateImageBuilderStreamingURLInput"} 1284 if v.Name == nil { 1285 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1286 } 1287 if invalidParams.Len() > 0 { 1288 return invalidParams 1289 } else { 1290 return nil 1291 } 1292} 1293 1294func validateOpCreateStackInput(v *CreateStackInput) error { 1295 if v == nil { 1296 return nil 1297 } 1298 invalidParams := smithy.InvalidParamsError{Context: "CreateStackInput"} 1299 if v.Name == nil { 1300 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1301 } 1302 if v.StorageConnectors != nil { 1303 if err := validateStorageConnectorList(v.StorageConnectors); err != nil { 1304 invalidParams.AddNested("StorageConnectors", err.(smithy.InvalidParamsError)) 1305 } 1306 } 1307 if v.UserSettings != nil { 1308 if err := validateUserSettingList(v.UserSettings); err != nil { 1309 invalidParams.AddNested("UserSettings", err.(smithy.InvalidParamsError)) 1310 } 1311 } 1312 if v.ApplicationSettings != nil { 1313 if err := validateApplicationSettings(v.ApplicationSettings); err != nil { 1314 invalidParams.AddNested("ApplicationSettings", err.(smithy.InvalidParamsError)) 1315 } 1316 } 1317 if v.AccessEndpoints != nil { 1318 if err := validateAccessEndpointList(v.AccessEndpoints); err != nil { 1319 invalidParams.AddNested("AccessEndpoints", err.(smithy.InvalidParamsError)) 1320 } 1321 } 1322 if invalidParams.Len() > 0 { 1323 return invalidParams 1324 } else { 1325 return nil 1326 } 1327} 1328 1329func validateOpCreateStreamingURLInput(v *CreateStreamingURLInput) error { 1330 if v == nil { 1331 return nil 1332 } 1333 invalidParams := smithy.InvalidParamsError{Context: "CreateStreamingURLInput"} 1334 if v.StackName == nil { 1335 invalidParams.Add(smithy.NewErrParamRequired("StackName")) 1336 } 1337 if v.FleetName == nil { 1338 invalidParams.Add(smithy.NewErrParamRequired("FleetName")) 1339 } 1340 if v.UserId == nil { 1341 invalidParams.Add(smithy.NewErrParamRequired("UserId")) 1342 } 1343 if invalidParams.Len() > 0 { 1344 return invalidParams 1345 } else { 1346 return nil 1347 } 1348} 1349 1350func validateOpCreateUpdatedImageInput(v *CreateUpdatedImageInput) error { 1351 if v == nil { 1352 return nil 1353 } 1354 invalidParams := smithy.InvalidParamsError{Context: "CreateUpdatedImageInput"} 1355 if v.ExistingImageName == nil { 1356 invalidParams.Add(smithy.NewErrParamRequired("ExistingImageName")) 1357 } 1358 if v.NewImageName == nil { 1359 invalidParams.Add(smithy.NewErrParamRequired("NewImageName")) 1360 } 1361 if invalidParams.Len() > 0 { 1362 return invalidParams 1363 } else { 1364 return nil 1365 } 1366} 1367 1368func validateOpCreateUserInput(v *CreateUserInput) error { 1369 if v == nil { 1370 return nil 1371 } 1372 invalidParams := smithy.InvalidParamsError{Context: "CreateUserInput"} 1373 if v.UserName == nil { 1374 invalidParams.Add(smithy.NewErrParamRequired("UserName")) 1375 } 1376 if len(v.AuthenticationType) == 0 { 1377 invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType")) 1378 } 1379 if invalidParams.Len() > 0 { 1380 return invalidParams 1381 } else { 1382 return nil 1383 } 1384} 1385 1386func validateOpDeleteDirectoryConfigInput(v *DeleteDirectoryConfigInput) error { 1387 if v == nil { 1388 return nil 1389 } 1390 invalidParams := smithy.InvalidParamsError{Context: "DeleteDirectoryConfigInput"} 1391 if v.DirectoryName == nil { 1392 invalidParams.Add(smithy.NewErrParamRequired("DirectoryName")) 1393 } 1394 if invalidParams.Len() > 0 { 1395 return invalidParams 1396 } else { 1397 return nil 1398 } 1399} 1400 1401func validateOpDeleteFleetInput(v *DeleteFleetInput) error { 1402 if v == nil { 1403 return nil 1404 } 1405 invalidParams := smithy.InvalidParamsError{Context: "DeleteFleetInput"} 1406 if v.Name == nil { 1407 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1408 } 1409 if invalidParams.Len() > 0 { 1410 return invalidParams 1411 } else { 1412 return nil 1413 } 1414} 1415 1416func validateOpDeleteImageBuilderInput(v *DeleteImageBuilderInput) error { 1417 if v == nil { 1418 return nil 1419 } 1420 invalidParams := smithy.InvalidParamsError{Context: "DeleteImageBuilderInput"} 1421 if v.Name == nil { 1422 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1423 } 1424 if invalidParams.Len() > 0 { 1425 return invalidParams 1426 } else { 1427 return nil 1428 } 1429} 1430 1431func validateOpDeleteImageInput(v *DeleteImageInput) error { 1432 if v == nil { 1433 return nil 1434 } 1435 invalidParams := smithy.InvalidParamsError{Context: "DeleteImageInput"} 1436 if v.Name == nil { 1437 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1438 } 1439 if invalidParams.Len() > 0 { 1440 return invalidParams 1441 } else { 1442 return nil 1443 } 1444} 1445 1446func validateOpDeleteImagePermissionsInput(v *DeleteImagePermissionsInput) error { 1447 if v == nil { 1448 return nil 1449 } 1450 invalidParams := smithy.InvalidParamsError{Context: "DeleteImagePermissionsInput"} 1451 if v.Name == nil { 1452 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1453 } 1454 if v.SharedAccountId == nil { 1455 invalidParams.Add(smithy.NewErrParamRequired("SharedAccountId")) 1456 } 1457 if invalidParams.Len() > 0 { 1458 return invalidParams 1459 } else { 1460 return nil 1461 } 1462} 1463 1464func validateOpDeleteStackInput(v *DeleteStackInput) error { 1465 if v == nil { 1466 return nil 1467 } 1468 invalidParams := smithy.InvalidParamsError{Context: "DeleteStackInput"} 1469 if v.Name == nil { 1470 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1471 } 1472 if invalidParams.Len() > 0 { 1473 return invalidParams 1474 } else { 1475 return nil 1476 } 1477} 1478 1479func validateOpDeleteUserInput(v *DeleteUserInput) error { 1480 if v == nil { 1481 return nil 1482 } 1483 invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"} 1484 if v.UserName == nil { 1485 invalidParams.Add(smithy.NewErrParamRequired("UserName")) 1486 } 1487 if len(v.AuthenticationType) == 0 { 1488 invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType")) 1489 } 1490 if invalidParams.Len() > 0 { 1491 return invalidParams 1492 } else { 1493 return nil 1494 } 1495} 1496 1497func validateOpDescribeImagePermissionsInput(v *DescribeImagePermissionsInput) error { 1498 if v == nil { 1499 return nil 1500 } 1501 invalidParams := smithy.InvalidParamsError{Context: "DescribeImagePermissionsInput"} 1502 if v.Name == nil { 1503 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1504 } 1505 if invalidParams.Len() > 0 { 1506 return invalidParams 1507 } else { 1508 return nil 1509 } 1510} 1511 1512func validateOpDescribeSessionsInput(v *DescribeSessionsInput) error { 1513 if v == nil { 1514 return nil 1515 } 1516 invalidParams := smithy.InvalidParamsError{Context: "DescribeSessionsInput"} 1517 if v.StackName == nil { 1518 invalidParams.Add(smithy.NewErrParamRequired("StackName")) 1519 } 1520 if v.FleetName == nil { 1521 invalidParams.Add(smithy.NewErrParamRequired("FleetName")) 1522 } 1523 if invalidParams.Len() > 0 { 1524 return invalidParams 1525 } else { 1526 return nil 1527 } 1528} 1529 1530func validateOpDescribeUsersInput(v *DescribeUsersInput) error { 1531 if v == nil { 1532 return nil 1533 } 1534 invalidParams := smithy.InvalidParamsError{Context: "DescribeUsersInput"} 1535 if len(v.AuthenticationType) == 0 { 1536 invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType")) 1537 } 1538 if invalidParams.Len() > 0 { 1539 return invalidParams 1540 } else { 1541 return nil 1542 } 1543} 1544 1545func validateOpDisableUserInput(v *DisableUserInput) error { 1546 if v == nil { 1547 return nil 1548 } 1549 invalidParams := smithy.InvalidParamsError{Context: "DisableUserInput"} 1550 if v.UserName == nil { 1551 invalidParams.Add(smithy.NewErrParamRequired("UserName")) 1552 } 1553 if len(v.AuthenticationType) == 0 { 1554 invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType")) 1555 } 1556 if invalidParams.Len() > 0 { 1557 return invalidParams 1558 } else { 1559 return nil 1560 } 1561} 1562 1563func validateOpDisassociateFleetInput(v *DisassociateFleetInput) error { 1564 if v == nil { 1565 return nil 1566 } 1567 invalidParams := smithy.InvalidParamsError{Context: "DisassociateFleetInput"} 1568 if v.FleetName == nil { 1569 invalidParams.Add(smithy.NewErrParamRequired("FleetName")) 1570 } 1571 if v.StackName == nil { 1572 invalidParams.Add(smithy.NewErrParamRequired("StackName")) 1573 } 1574 if invalidParams.Len() > 0 { 1575 return invalidParams 1576 } else { 1577 return nil 1578 } 1579} 1580 1581func validateOpEnableUserInput(v *EnableUserInput) error { 1582 if v == nil { 1583 return nil 1584 } 1585 invalidParams := smithy.InvalidParamsError{Context: "EnableUserInput"} 1586 if v.UserName == nil { 1587 invalidParams.Add(smithy.NewErrParamRequired("UserName")) 1588 } 1589 if len(v.AuthenticationType) == 0 { 1590 invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType")) 1591 } 1592 if invalidParams.Len() > 0 { 1593 return invalidParams 1594 } else { 1595 return nil 1596 } 1597} 1598 1599func validateOpExpireSessionInput(v *ExpireSessionInput) error { 1600 if v == nil { 1601 return nil 1602 } 1603 invalidParams := smithy.InvalidParamsError{Context: "ExpireSessionInput"} 1604 if v.SessionId == nil { 1605 invalidParams.Add(smithy.NewErrParamRequired("SessionId")) 1606 } 1607 if invalidParams.Len() > 0 { 1608 return invalidParams 1609 } else { 1610 return nil 1611 } 1612} 1613 1614func validateOpListAssociatedFleetsInput(v *ListAssociatedFleetsInput) error { 1615 if v == nil { 1616 return nil 1617 } 1618 invalidParams := smithy.InvalidParamsError{Context: "ListAssociatedFleetsInput"} 1619 if v.StackName == nil { 1620 invalidParams.Add(smithy.NewErrParamRequired("StackName")) 1621 } 1622 if invalidParams.Len() > 0 { 1623 return invalidParams 1624 } else { 1625 return nil 1626 } 1627} 1628 1629func validateOpListAssociatedStacksInput(v *ListAssociatedStacksInput) error { 1630 if v == nil { 1631 return nil 1632 } 1633 invalidParams := smithy.InvalidParamsError{Context: "ListAssociatedStacksInput"} 1634 if v.FleetName == nil { 1635 invalidParams.Add(smithy.NewErrParamRequired("FleetName")) 1636 } 1637 if invalidParams.Len() > 0 { 1638 return invalidParams 1639 } else { 1640 return nil 1641 } 1642} 1643 1644func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1645 if v == nil { 1646 return nil 1647 } 1648 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1649 if v.ResourceArn == nil { 1650 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1651 } 1652 if invalidParams.Len() > 0 { 1653 return invalidParams 1654 } else { 1655 return nil 1656 } 1657} 1658 1659func validateOpStartFleetInput(v *StartFleetInput) error { 1660 if v == nil { 1661 return nil 1662 } 1663 invalidParams := smithy.InvalidParamsError{Context: "StartFleetInput"} 1664 if v.Name == nil { 1665 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1666 } 1667 if invalidParams.Len() > 0 { 1668 return invalidParams 1669 } else { 1670 return nil 1671 } 1672} 1673 1674func validateOpStartImageBuilderInput(v *StartImageBuilderInput) error { 1675 if v == nil { 1676 return nil 1677 } 1678 invalidParams := smithy.InvalidParamsError{Context: "StartImageBuilderInput"} 1679 if v.Name == nil { 1680 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1681 } 1682 if invalidParams.Len() > 0 { 1683 return invalidParams 1684 } else { 1685 return nil 1686 } 1687} 1688 1689func validateOpStopFleetInput(v *StopFleetInput) error { 1690 if v == nil { 1691 return nil 1692 } 1693 invalidParams := smithy.InvalidParamsError{Context: "StopFleetInput"} 1694 if v.Name == nil { 1695 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1696 } 1697 if invalidParams.Len() > 0 { 1698 return invalidParams 1699 } else { 1700 return nil 1701 } 1702} 1703 1704func validateOpStopImageBuilderInput(v *StopImageBuilderInput) error { 1705 if v == nil { 1706 return nil 1707 } 1708 invalidParams := smithy.InvalidParamsError{Context: "StopImageBuilderInput"} 1709 if v.Name == nil { 1710 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1711 } 1712 if invalidParams.Len() > 0 { 1713 return invalidParams 1714 } else { 1715 return nil 1716 } 1717} 1718 1719func validateOpTagResourceInput(v *TagResourceInput) error { 1720 if v == nil { 1721 return nil 1722 } 1723 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1724 if v.ResourceArn == nil { 1725 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1726 } 1727 if v.Tags == nil { 1728 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1729 } 1730 if invalidParams.Len() > 0 { 1731 return invalidParams 1732 } else { 1733 return nil 1734 } 1735} 1736 1737func validateOpUntagResourceInput(v *UntagResourceInput) error { 1738 if v == nil { 1739 return nil 1740 } 1741 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1742 if v.ResourceArn == nil { 1743 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1744 } 1745 if v.TagKeys == nil { 1746 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1747 } 1748 if invalidParams.Len() > 0 { 1749 return invalidParams 1750 } else { 1751 return nil 1752 } 1753} 1754 1755func validateOpUpdateDirectoryConfigInput(v *UpdateDirectoryConfigInput) error { 1756 if v == nil { 1757 return nil 1758 } 1759 invalidParams := smithy.InvalidParamsError{Context: "UpdateDirectoryConfigInput"} 1760 if v.DirectoryName == nil { 1761 invalidParams.Add(smithy.NewErrParamRequired("DirectoryName")) 1762 } 1763 if v.ServiceAccountCredentials != nil { 1764 if err := validateServiceAccountCredentials(v.ServiceAccountCredentials); err != nil { 1765 invalidParams.AddNested("ServiceAccountCredentials", err.(smithy.InvalidParamsError)) 1766 } 1767 } 1768 if invalidParams.Len() > 0 { 1769 return invalidParams 1770 } else { 1771 return nil 1772 } 1773} 1774 1775func validateOpUpdateFleetInput(v *UpdateFleetInput) error { 1776 if v == nil { 1777 return nil 1778 } 1779 invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetInput"} 1780 if v.ComputeCapacity != nil { 1781 if err := validateComputeCapacity(v.ComputeCapacity); err != nil { 1782 invalidParams.AddNested("ComputeCapacity", err.(smithy.InvalidParamsError)) 1783 } 1784 } 1785 if invalidParams.Len() > 0 { 1786 return invalidParams 1787 } else { 1788 return nil 1789 } 1790} 1791 1792func validateOpUpdateImagePermissionsInput(v *UpdateImagePermissionsInput) error { 1793 if v == nil { 1794 return nil 1795 } 1796 invalidParams := smithy.InvalidParamsError{Context: "UpdateImagePermissionsInput"} 1797 if v.Name == nil { 1798 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1799 } 1800 if v.SharedAccountId == nil { 1801 invalidParams.Add(smithy.NewErrParamRequired("SharedAccountId")) 1802 } 1803 if v.ImagePermissions == nil { 1804 invalidParams.Add(smithy.NewErrParamRequired("ImagePermissions")) 1805 } 1806 if invalidParams.Len() > 0 { 1807 return invalidParams 1808 } else { 1809 return nil 1810 } 1811} 1812 1813func validateOpUpdateStackInput(v *UpdateStackInput) error { 1814 if v == nil { 1815 return nil 1816 } 1817 invalidParams := smithy.InvalidParamsError{Context: "UpdateStackInput"} 1818 if v.Name == nil { 1819 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1820 } 1821 if v.StorageConnectors != nil { 1822 if err := validateStorageConnectorList(v.StorageConnectors); err != nil { 1823 invalidParams.AddNested("StorageConnectors", err.(smithy.InvalidParamsError)) 1824 } 1825 } 1826 if v.UserSettings != nil { 1827 if err := validateUserSettingList(v.UserSettings); err != nil { 1828 invalidParams.AddNested("UserSettings", err.(smithy.InvalidParamsError)) 1829 } 1830 } 1831 if v.ApplicationSettings != nil { 1832 if err := validateApplicationSettings(v.ApplicationSettings); err != nil { 1833 invalidParams.AddNested("ApplicationSettings", err.(smithy.InvalidParamsError)) 1834 } 1835 } 1836 if v.AccessEndpoints != nil { 1837 if err := validateAccessEndpointList(v.AccessEndpoints); err != nil { 1838 invalidParams.AddNested("AccessEndpoints", err.(smithy.InvalidParamsError)) 1839 } 1840 } 1841 if invalidParams.Len() > 0 { 1842 return invalidParams 1843 } else { 1844 return nil 1845 } 1846} 1847