1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package fsx 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/fsx/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAssociateFileSystemAliases struct { 14} 15 16func (*validateOpAssociateFileSystemAliases) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAssociateFileSystemAliases) 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.(*AssociateFileSystemAliasesInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAssociateFileSystemAliasesInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCancelDataRepositoryTask struct { 34} 35 36func (*validateOpCancelDataRepositoryTask) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCancelDataRepositoryTask) 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.(*CancelDataRepositoryTaskInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCancelDataRepositoryTaskInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateBackup struct { 54} 55 56func (*validateOpCreateBackup) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateBackup) 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.(*CreateBackupInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateBackupInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateDataRepositoryTask struct { 74} 75 76func (*validateOpCreateDataRepositoryTask) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateDataRepositoryTask) 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.(*CreateDataRepositoryTaskInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateDataRepositoryTaskInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateFileSystemFromBackup struct { 94} 95 96func (*validateOpCreateFileSystemFromBackup) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateFileSystemFromBackup) 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.(*CreateFileSystemFromBackupInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateFileSystemFromBackupInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateFileSystem struct { 114} 115 116func (*validateOpCreateFileSystem) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateFileSystem) 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.(*CreateFileSystemInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateFileSystemInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteBackup struct { 134} 135 136func (*validateOpDeleteBackup) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteBackup) 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.(*DeleteBackupInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteBackupInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteFileSystem struct { 154} 155 156func (*validateOpDeleteFileSystem) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteFileSystem) 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.(*DeleteFileSystemInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteFileSystemInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDescribeFileSystemAliases struct { 174} 175 176func (*validateOpDescribeFileSystemAliases) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDescribeFileSystemAliases) 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.(*DescribeFileSystemAliasesInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDescribeFileSystemAliasesInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDisassociateFileSystemAliases struct { 194} 195 196func (*validateOpDisassociateFileSystemAliases) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDisassociateFileSystemAliases) 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.(*DisassociateFileSystemAliasesInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDisassociateFileSystemAliasesInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpListTagsForResource struct { 214} 215 216func (*validateOpListTagsForResource) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpListTagsForResourceInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpTagResource struct { 234} 235 236func (*validateOpTagResource) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpTagResource) 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.(*TagResourceInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpTagResourceInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpUntagResource struct { 254} 255 256func (*validateOpUntagResource) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpUntagResource) 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.(*UntagResourceInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpUntagResourceInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpUpdateFileSystem struct { 274} 275 276func (*validateOpUpdateFileSystem) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpUpdateFileSystem) 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.(*UpdateFileSystemInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpUpdateFileSystemInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293func addOpAssociateFileSystemAliasesValidationMiddleware(stack *middleware.Stack) error { 294 return stack.Initialize.Add(&validateOpAssociateFileSystemAliases{}, middleware.After) 295} 296 297func addOpCancelDataRepositoryTaskValidationMiddleware(stack *middleware.Stack) error { 298 return stack.Initialize.Add(&validateOpCancelDataRepositoryTask{}, middleware.After) 299} 300 301func addOpCreateBackupValidationMiddleware(stack *middleware.Stack) error { 302 return stack.Initialize.Add(&validateOpCreateBackup{}, middleware.After) 303} 304 305func addOpCreateDataRepositoryTaskValidationMiddleware(stack *middleware.Stack) error { 306 return stack.Initialize.Add(&validateOpCreateDataRepositoryTask{}, middleware.After) 307} 308 309func addOpCreateFileSystemFromBackupValidationMiddleware(stack *middleware.Stack) error { 310 return stack.Initialize.Add(&validateOpCreateFileSystemFromBackup{}, middleware.After) 311} 312 313func addOpCreateFileSystemValidationMiddleware(stack *middleware.Stack) error { 314 return stack.Initialize.Add(&validateOpCreateFileSystem{}, middleware.After) 315} 316 317func addOpDeleteBackupValidationMiddleware(stack *middleware.Stack) error { 318 return stack.Initialize.Add(&validateOpDeleteBackup{}, middleware.After) 319} 320 321func addOpDeleteFileSystemValidationMiddleware(stack *middleware.Stack) error { 322 return stack.Initialize.Add(&validateOpDeleteFileSystem{}, middleware.After) 323} 324 325func addOpDescribeFileSystemAliasesValidationMiddleware(stack *middleware.Stack) error { 326 return stack.Initialize.Add(&validateOpDescribeFileSystemAliases{}, middleware.After) 327} 328 329func addOpDisassociateFileSystemAliasesValidationMiddleware(stack *middleware.Stack) error { 330 return stack.Initialize.Add(&validateOpDisassociateFileSystemAliases{}, middleware.After) 331} 332 333func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 334 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 335} 336 337func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 338 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 339} 340 341func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 342 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 343} 344 345func addOpUpdateFileSystemValidationMiddleware(stack *middleware.Stack) error { 346 return stack.Initialize.Add(&validateOpUpdateFileSystem{}, middleware.After) 347} 348 349func validateCompletionReport(v *types.CompletionReport) error { 350 if v == nil { 351 return nil 352 } 353 invalidParams := smithy.InvalidParamsError{Context: "CompletionReport"} 354 if v.Enabled == nil { 355 invalidParams.Add(smithy.NewErrParamRequired("Enabled")) 356 } 357 if invalidParams.Len() > 0 { 358 return invalidParams 359 } else { 360 return nil 361 } 362} 363 364func validateCreateFileSystemWindowsConfiguration(v *types.CreateFileSystemWindowsConfiguration) error { 365 if v == nil { 366 return nil 367 } 368 invalidParams := smithy.InvalidParamsError{Context: "CreateFileSystemWindowsConfiguration"} 369 if v.SelfManagedActiveDirectoryConfiguration != nil { 370 if err := validateSelfManagedActiveDirectoryConfiguration(v.SelfManagedActiveDirectoryConfiguration); err != nil { 371 invalidParams.AddNested("SelfManagedActiveDirectoryConfiguration", err.(smithy.InvalidParamsError)) 372 } 373 } 374 if v.ThroughputCapacity == nil { 375 invalidParams.Add(smithy.NewErrParamRequired("ThroughputCapacity")) 376 } 377 if invalidParams.Len() > 0 { 378 return invalidParams 379 } else { 380 return nil 381 } 382} 383 384func validateDeleteFileSystemLustreConfiguration(v *types.DeleteFileSystemLustreConfiguration) error { 385 if v == nil { 386 return nil 387 } 388 invalidParams := smithy.InvalidParamsError{Context: "DeleteFileSystemLustreConfiguration"} 389 if v.FinalBackupTags != nil { 390 if err := validateTags(v.FinalBackupTags); err != nil { 391 invalidParams.AddNested("FinalBackupTags", err.(smithy.InvalidParamsError)) 392 } 393 } 394 if invalidParams.Len() > 0 { 395 return invalidParams 396 } else { 397 return nil 398 } 399} 400 401func validateDeleteFileSystemWindowsConfiguration(v *types.DeleteFileSystemWindowsConfiguration) error { 402 if v == nil { 403 return nil 404 } 405 invalidParams := smithy.InvalidParamsError{Context: "DeleteFileSystemWindowsConfiguration"} 406 if v.FinalBackupTags != nil { 407 if err := validateTags(v.FinalBackupTags); err != nil { 408 invalidParams.AddNested("FinalBackupTags", err.(smithy.InvalidParamsError)) 409 } 410 } 411 if invalidParams.Len() > 0 { 412 return invalidParams 413 } else { 414 return nil 415 } 416} 417 418func validateSelfManagedActiveDirectoryConfiguration(v *types.SelfManagedActiveDirectoryConfiguration) error { 419 if v == nil { 420 return nil 421 } 422 invalidParams := smithy.InvalidParamsError{Context: "SelfManagedActiveDirectoryConfiguration"} 423 if v.DomainName == nil { 424 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 425 } 426 if v.UserName == nil { 427 invalidParams.Add(smithy.NewErrParamRequired("UserName")) 428 } 429 if v.Password == nil { 430 invalidParams.Add(smithy.NewErrParamRequired("Password")) 431 } 432 if v.DnsIps == nil { 433 invalidParams.Add(smithy.NewErrParamRequired("DnsIps")) 434 } 435 if invalidParams.Len() > 0 { 436 return invalidParams 437 } else { 438 return nil 439 } 440} 441 442func validateTag(v *types.Tag) error { 443 if v == nil { 444 return nil 445 } 446 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 447 if v.Key == nil { 448 invalidParams.Add(smithy.NewErrParamRequired("Key")) 449 } 450 if v.Value == nil { 451 invalidParams.Add(smithy.NewErrParamRequired("Value")) 452 } 453 if invalidParams.Len() > 0 { 454 return invalidParams 455 } else { 456 return nil 457 } 458} 459 460func validateTags(v []types.Tag) error { 461 if v == nil { 462 return nil 463 } 464 invalidParams := smithy.InvalidParamsError{Context: "Tags"} 465 for i := range v { 466 if err := validateTag(&v[i]); err != nil { 467 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 468 } 469 } 470 if invalidParams.Len() > 0 { 471 return invalidParams 472 } else { 473 return nil 474 } 475} 476 477func validateOpAssociateFileSystemAliasesInput(v *AssociateFileSystemAliasesInput) error { 478 if v == nil { 479 return nil 480 } 481 invalidParams := smithy.InvalidParamsError{Context: "AssociateFileSystemAliasesInput"} 482 if v.FileSystemId == nil { 483 invalidParams.Add(smithy.NewErrParamRequired("FileSystemId")) 484 } 485 if v.Aliases == nil { 486 invalidParams.Add(smithy.NewErrParamRequired("Aliases")) 487 } 488 if invalidParams.Len() > 0 { 489 return invalidParams 490 } else { 491 return nil 492 } 493} 494 495func validateOpCancelDataRepositoryTaskInput(v *CancelDataRepositoryTaskInput) error { 496 if v == nil { 497 return nil 498 } 499 invalidParams := smithy.InvalidParamsError{Context: "CancelDataRepositoryTaskInput"} 500 if v.TaskId == nil { 501 invalidParams.Add(smithy.NewErrParamRequired("TaskId")) 502 } 503 if invalidParams.Len() > 0 { 504 return invalidParams 505 } else { 506 return nil 507 } 508} 509 510func validateOpCreateBackupInput(v *CreateBackupInput) error { 511 if v == nil { 512 return nil 513 } 514 invalidParams := smithy.InvalidParamsError{Context: "CreateBackupInput"} 515 if v.FileSystemId == nil { 516 invalidParams.Add(smithy.NewErrParamRequired("FileSystemId")) 517 } 518 if v.Tags != nil { 519 if err := validateTags(v.Tags); err != nil { 520 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 521 } 522 } 523 if invalidParams.Len() > 0 { 524 return invalidParams 525 } else { 526 return nil 527 } 528} 529 530func validateOpCreateDataRepositoryTaskInput(v *CreateDataRepositoryTaskInput) error { 531 if v == nil { 532 return nil 533 } 534 invalidParams := smithy.InvalidParamsError{Context: "CreateDataRepositoryTaskInput"} 535 if len(v.Type) == 0 { 536 invalidParams.Add(smithy.NewErrParamRequired("Type")) 537 } 538 if v.FileSystemId == nil { 539 invalidParams.Add(smithy.NewErrParamRequired("FileSystemId")) 540 } 541 if v.Report == nil { 542 invalidParams.Add(smithy.NewErrParamRequired("Report")) 543 } else if v.Report != nil { 544 if err := validateCompletionReport(v.Report); err != nil { 545 invalidParams.AddNested("Report", err.(smithy.InvalidParamsError)) 546 } 547 } 548 if v.Tags != nil { 549 if err := validateTags(v.Tags); err != nil { 550 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 551 } 552 } 553 if invalidParams.Len() > 0 { 554 return invalidParams 555 } else { 556 return nil 557 } 558} 559 560func validateOpCreateFileSystemFromBackupInput(v *CreateFileSystemFromBackupInput) error { 561 if v == nil { 562 return nil 563 } 564 invalidParams := smithy.InvalidParamsError{Context: "CreateFileSystemFromBackupInput"} 565 if v.BackupId == nil { 566 invalidParams.Add(smithy.NewErrParamRequired("BackupId")) 567 } 568 if v.SubnetIds == nil { 569 invalidParams.Add(smithy.NewErrParamRequired("SubnetIds")) 570 } 571 if v.Tags != nil { 572 if err := validateTags(v.Tags); err != nil { 573 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 574 } 575 } 576 if v.WindowsConfiguration != nil { 577 if err := validateCreateFileSystemWindowsConfiguration(v.WindowsConfiguration); err != nil { 578 invalidParams.AddNested("WindowsConfiguration", err.(smithy.InvalidParamsError)) 579 } 580 } 581 if invalidParams.Len() > 0 { 582 return invalidParams 583 } else { 584 return nil 585 } 586} 587 588func validateOpCreateFileSystemInput(v *CreateFileSystemInput) error { 589 if v == nil { 590 return nil 591 } 592 invalidParams := smithy.InvalidParamsError{Context: "CreateFileSystemInput"} 593 if len(v.FileSystemType) == 0 { 594 invalidParams.Add(smithy.NewErrParamRequired("FileSystemType")) 595 } 596 if v.StorageCapacity == nil { 597 invalidParams.Add(smithy.NewErrParamRequired("StorageCapacity")) 598 } 599 if v.SubnetIds == nil { 600 invalidParams.Add(smithy.NewErrParamRequired("SubnetIds")) 601 } 602 if v.Tags != nil { 603 if err := validateTags(v.Tags); err != nil { 604 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 605 } 606 } 607 if v.WindowsConfiguration != nil { 608 if err := validateCreateFileSystemWindowsConfiguration(v.WindowsConfiguration); err != nil { 609 invalidParams.AddNested("WindowsConfiguration", err.(smithy.InvalidParamsError)) 610 } 611 } 612 if invalidParams.Len() > 0 { 613 return invalidParams 614 } else { 615 return nil 616 } 617} 618 619func validateOpDeleteBackupInput(v *DeleteBackupInput) error { 620 if v == nil { 621 return nil 622 } 623 invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupInput"} 624 if v.BackupId == nil { 625 invalidParams.Add(smithy.NewErrParamRequired("BackupId")) 626 } 627 if invalidParams.Len() > 0 { 628 return invalidParams 629 } else { 630 return nil 631 } 632} 633 634func validateOpDeleteFileSystemInput(v *DeleteFileSystemInput) error { 635 if v == nil { 636 return nil 637 } 638 invalidParams := smithy.InvalidParamsError{Context: "DeleteFileSystemInput"} 639 if v.FileSystemId == nil { 640 invalidParams.Add(smithy.NewErrParamRequired("FileSystemId")) 641 } 642 if v.WindowsConfiguration != nil { 643 if err := validateDeleteFileSystemWindowsConfiguration(v.WindowsConfiguration); err != nil { 644 invalidParams.AddNested("WindowsConfiguration", err.(smithy.InvalidParamsError)) 645 } 646 } 647 if v.LustreConfiguration != nil { 648 if err := validateDeleteFileSystemLustreConfiguration(v.LustreConfiguration); err != nil { 649 invalidParams.AddNested("LustreConfiguration", err.(smithy.InvalidParamsError)) 650 } 651 } 652 if invalidParams.Len() > 0 { 653 return invalidParams 654 } else { 655 return nil 656 } 657} 658 659func validateOpDescribeFileSystemAliasesInput(v *DescribeFileSystemAliasesInput) error { 660 if v == nil { 661 return nil 662 } 663 invalidParams := smithy.InvalidParamsError{Context: "DescribeFileSystemAliasesInput"} 664 if v.FileSystemId == nil { 665 invalidParams.Add(smithy.NewErrParamRequired("FileSystemId")) 666 } 667 if invalidParams.Len() > 0 { 668 return invalidParams 669 } else { 670 return nil 671 } 672} 673 674func validateOpDisassociateFileSystemAliasesInput(v *DisassociateFileSystemAliasesInput) error { 675 if v == nil { 676 return nil 677 } 678 invalidParams := smithy.InvalidParamsError{Context: "DisassociateFileSystemAliasesInput"} 679 if v.FileSystemId == nil { 680 invalidParams.Add(smithy.NewErrParamRequired("FileSystemId")) 681 } 682 if v.Aliases == nil { 683 invalidParams.Add(smithy.NewErrParamRequired("Aliases")) 684 } 685 if invalidParams.Len() > 0 { 686 return invalidParams 687 } else { 688 return nil 689 } 690} 691 692func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 693 if v == nil { 694 return nil 695 } 696 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 697 if v.ResourceARN == nil { 698 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 699 } 700 if invalidParams.Len() > 0 { 701 return invalidParams 702 } else { 703 return nil 704 } 705} 706 707func validateOpTagResourceInput(v *TagResourceInput) error { 708 if v == nil { 709 return nil 710 } 711 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 712 if v.ResourceARN == nil { 713 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 714 } 715 if v.Tags == nil { 716 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 717 } else if v.Tags != nil { 718 if err := validateTags(v.Tags); err != nil { 719 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 720 } 721 } 722 if invalidParams.Len() > 0 { 723 return invalidParams 724 } else { 725 return nil 726 } 727} 728 729func validateOpUntagResourceInput(v *UntagResourceInput) error { 730 if v == nil { 731 return nil 732 } 733 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 734 if v.ResourceARN == nil { 735 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 736 } 737 if v.TagKeys == nil { 738 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 739 } 740 if invalidParams.Len() > 0 { 741 return invalidParams 742 } else { 743 return nil 744 } 745} 746 747func validateOpUpdateFileSystemInput(v *UpdateFileSystemInput) error { 748 if v == nil { 749 return nil 750 } 751 invalidParams := smithy.InvalidParamsError{Context: "UpdateFileSystemInput"} 752 if v.FileSystemId == nil { 753 invalidParams.Add(smithy.NewErrParamRequired("FileSystemId")) 754 } 755 if invalidParams.Len() > 0 { 756 return invalidParams 757 } else { 758 return nil 759 } 760} 761