1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package lexmodelbuildingservice 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/lexmodelbuildingservice/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpCreateBotVersion struct { 14} 15 16func (*validateOpCreateBotVersion) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpCreateBotVersion) 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.(*CreateBotVersionInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpCreateBotVersionInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateIntentVersion struct { 34} 35 36func (*validateOpCreateIntentVersion) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateIntentVersion) 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.(*CreateIntentVersionInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateIntentVersionInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateSlotTypeVersion struct { 54} 55 56func (*validateOpCreateSlotTypeVersion) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateSlotTypeVersion) 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.(*CreateSlotTypeVersionInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateSlotTypeVersionInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpDeleteBotAlias struct { 74} 75 76func (*validateOpDeleteBotAlias) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpDeleteBotAlias) 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.(*DeleteBotAliasInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpDeleteBotAliasInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpDeleteBotChannelAssociation struct { 94} 95 96func (*validateOpDeleteBotChannelAssociation) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpDeleteBotChannelAssociation) 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.(*DeleteBotChannelAssociationInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpDeleteBotChannelAssociationInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeleteBot struct { 114} 115 116func (*validateOpDeleteBot) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeleteBot) 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.(*DeleteBotInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeleteBotInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteBotVersion struct { 134} 135 136func (*validateOpDeleteBotVersion) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteBotVersion) 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.(*DeleteBotVersionInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteBotVersionInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteIntent struct { 154} 155 156func (*validateOpDeleteIntent) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteIntent) 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.(*DeleteIntentInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteIntentInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteIntentVersion struct { 174} 175 176func (*validateOpDeleteIntentVersion) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteIntentVersion) 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.(*DeleteIntentVersionInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteIntentVersionInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteSlotType struct { 194} 195 196func (*validateOpDeleteSlotType) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteSlotType) 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.(*DeleteSlotTypeInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteSlotTypeInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteSlotTypeVersion struct { 214} 215 216func (*validateOpDeleteSlotTypeVersion) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteSlotTypeVersion) 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.(*DeleteSlotTypeVersionInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteSlotTypeVersionInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteUtterances struct { 234} 235 236func (*validateOpDeleteUtterances) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteUtterances) 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.(*DeleteUtterancesInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteUtterancesInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpGetBotAliases struct { 254} 255 256func (*validateOpGetBotAliases) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpGetBotAliases) 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.(*GetBotAliasesInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpGetBotAliasesInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpGetBotAlias struct { 274} 275 276func (*validateOpGetBotAlias) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpGetBotAlias) 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.(*GetBotAliasInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpGetBotAliasInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpGetBotChannelAssociation struct { 294} 295 296func (*validateOpGetBotChannelAssociation) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpGetBotChannelAssociation) 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.(*GetBotChannelAssociationInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpGetBotChannelAssociationInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpGetBotChannelAssociations struct { 314} 315 316func (*validateOpGetBotChannelAssociations) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpGetBotChannelAssociations) 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.(*GetBotChannelAssociationsInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpGetBotChannelAssociationsInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpGetBot struct { 334} 335 336func (*validateOpGetBot) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpGetBot) 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.(*GetBotInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpGetBotInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpGetBotVersions struct { 354} 355 356func (*validateOpGetBotVersions) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpGetBotVersions) 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.(*GetBotVersionsInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpGetBotVersionsInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpGetBuiltinIntent struct { 374} 375 376func (*validateOpGetBuiltinIntent) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpGetBuiltinIntent) 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.(*GetBuiltinIntentInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpGetBuiltinIntentInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpGetExport struct { 394} 395 396func (*validateOpGetExport) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpGetExport) 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.(*GetExportInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpGetExportInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpGetImport struct { 414} 415 416func (*validateOpGetImport) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpGetImport) 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.(*GetImportInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpGetImportInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpGetIntent struct { 434} 435 436func (*validateOpGetIntent) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpGetIntent) 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.(*GetIntentInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpGetIntentInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpGetIntentVersions struct { 454} 455 456func (*validateOpGetIntentVersions) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpGetIntentVersions) 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.(*GetIntentVersionsInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpGetIntentVersionsInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpGetSlotType struct { 474} 475 476func (*validateOpGetSlotType) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpGetSlotType) 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.(*GetSlotTypeInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpGetSlotTypeInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpGetSlotTypeVersions struct { 494} 495 496func (*validateOpGetSlotTypeVersions) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpGetSlotTypeVersions) 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.(*GetSlotTypeVersionsInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpGetSlotTypeVersionsInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpGetUtterancesView struct { 514} 515 516func (*validateOpGetUtterancesView) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpGetUtterancesView) 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.(*GetUtterancesViewInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpGetUtterancesViewInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpListTagsForResource struct { 534} 535 536func (*validateOpListTagsForResource) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpListTagsForResourceInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpPutBotAlias struct { 554} 555 556func (*validateOpPutBotAlias) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpPutBotAlias) 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.(*PutBotAliasInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpPutBotAliasInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpPutBot struct { 574} 575 576func (*validateOpPutBot) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpPutBot) 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.(*PutBotInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpPutBotInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpPutIntent struct { 594} 595 596func (*validateOpPutIntent) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpPutIntent) 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.(*PutIntentInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpPutIntentInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpPutSlotType struct { 614} 615 616func (*validateOpPutSlotType) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpPutSlotType) 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.(*PutSlotTypeInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpPutSlotTypeInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpStartImport struct { 634} 635 636func (*validateOpStartImport) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpStartImport) 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.(*StartImportInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpStartImportInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpTagResource struct { 654} 655 656func (*validateOpTagResource) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpTagResource) 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.(*TagResourceInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpTagResourceInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpUntagResource struct { 674} 675 676func (*validateOpUntagResource) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpUntagResource) 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.(*UntagResourceInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpUntagResourceInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693func addOpCreateBotVersionValidationMiddleware(stack *middleware.Stack) error { 694 return stack.Initialize.Add(&validateOpCreateBotVersion{}, middleware.After) 695} 696 697func addOpCreateIntentVersionValidationMiddleware(stack *middleware.Stack) error { 698 return stack.Initialize.Add(&validateOpCreateIntentVersion{}, middleware.After) 699} 700 701func addOpCreateSlotTypeVersionValidationMiddleware(stack *middleware.Stack) error { 702 return stack.Initialize.Add(&validateOpCreateSlotTypeVersion{}, middleware.After) 703} 704 705func addOpDeleteBotAliasValidationMiddleware(stack *middleware.Stack) error { 706 return stack.Initialize.Add(&validateOpDeleteBotAlias{}, middleware.After) 707} 708 709func addOpDeleteBotChannelAssociationValidationMiddleware(stack *middleware.Stack) error { 710 return stack.Initialize.Add(&validateOpDeleteBotChannelAssociation{}, middleware.After) 711} 712 713func addOpDeleteBotValidationMiddleware(stack *middleware.Stack) error { 714 return stack.Initialize.Add(&validateOpDeleteBot{}, middleware.After) 715} 716 717func addOpDeleteBotVersionValidationMiddleware(stack *middleware.Stack) error { 718 return stack.Initialize.Add(&validateOpDeleteBotVersion{}, middleware.After) 719} 720 721func addOpDeleteIntentValidationMiddleware(stack *middleware.Stack) error { 722 return stack.Initialize.Add(&validateOpDeleteIntent{}, middleware.After) 723} 724 725func addOpDeleteIntentVersionValidationMiddleware(stack *middleware.Stack) error { 726 return stack.Initialize.Add(&validateOpDeleteIntentVersion{}, middleware.After) 727} 728 729func addOpDeleteSlotTypeValidationMiddleware(stack *middleware.Stack) error { 730 return stack.Initialize.Add(&validateOpDeleteSlotType{}, middleware.After) 731} 732 733func addOpDeleteSlotTypeVersionValidationMiddleware(stack *middleware.Stack) error { 734 return stack.Initialize.Add(&validateOpDeleteSlotTypeVersion{}, middleware.After) 735} 736 737func addOpDeleteUtterancesValidationMiddleware(stack *middleware.Stack) error { 738 return stack.Initialize.Add(&validateOpDeleteUtterances{}, middleware.After) 739} 740 741func addOpGetBotAliasesValidationMiddleware(stack *middleware.Stack) error { 742 return stack.Initialize.Add(&validateOpGetBotAliases{}, middleware.After) 743} 744 745func addOpGetBotAliasValidationMiddleware(stack *middleware.Stack) error { 746 return stack.Initialize.Add(&validateOpGetBotAlias{}, middleware.After) 747} 748 749func addOpGetBotChannelAssociationValidationMiddleware(stack *middleware.Stack) error { 750 return stack.Initialize.Add(&validateOpGetBotChannelAssociation{}, middleware.After) 751} 752 753func addOpGetBotChannelAssociationsValidationMiddleware(stack *middleware.Stack) error { 754 return stack.Initialize.Add(&validateOpGetBotChannelAssociations{}, middleware.After) 755} 756 757func addOpGetBotValidationMiddleware(stack *middleware.Stack) error { 758 return stack.Initialize.Add(&validateOpGetBot{}, middleware.After) 759} 760 761func addOpGetBotVersionsValidationMiddleware(stack *middleware.Stack) error { 762 return stack.Initialize.Add(&validateOpGetBotVersions{}, middleware.After) 763} 764 765func addOpGetBuiltinIntentValidationMiddleware(stack *middleware.Stack) error { 766 return stack.Initialize.Add(&validateOpGetBuiltinIntent{}, middleware.After) 767} 768 769func addOpGetExportValidationMiddleware(stack *middleware.Stack) error { 770 return stack.Initialize.Add(&validateOpGetExport{}, middleware.After) 771} 772 773func addOpGetImportValidationMiddleware(stack *middleware.Stack) error { 774 return stack.Initialize.Add(&validateOpGetImport{}, middleware.After) 775} 776 777func addOpGetIntentValidationMiddleware(stack *middleware.Stack) error { 778 return stack.Initialize.Add(&validateOpGetIntent{}, middleware.After) 779} 780 781func addOpGetIntentVersionsValidationMiddleware(stack *middleware.Stack) error { 782 return stack.Initialize.Add(&validateOpGetIntentVersions{}, middleware.After) 783} 784 785func addOpGetSlotTypeValidationMiddleware(stack *middleware.Stack) error { 786 return stack.Initialize.Add(&validateOpGetSlotType{}, middleware.After) 787} 788 789func addOpGetSlotTypeVersionsValidationMiddleware(stack *middleware.Stack) error { 790 return stack.Initialize.Add(&validateOpGetSlotTypeVersions{}, middleware.After) 791} 792 793func addOpGetUtterancesViewValidationMiddleware(stack *middleware.Stack) error { 794 return stack.Initialize.Add(&validateOpGetUtterancesView{}, middleware.After) 795} 796 797func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 798 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 799} 800 801func addOpPutBotAliasValidationMiddleware(stack *middleware.Stack) error { 802 return stack.Initialize.Add(&validateOpPutBotAlias{}, middleware.After) 803} 804 805func addOpPutBotValidationMiddleware(stack *middleware.Stack) error { 806 return stack.Initialize.Add(&validateOpPutBot{}, middleware.After) 807} 808 809func addOpPutIntentValidationMiddleware(stack *middleware.Stack) error { 810 return stack.Initialize.Add(&validateOpPutIntent{}, middleware.After) 811} 812 813func addOpPutSlotTypeValidationMiddleware(stack *middleware.Stack) error { 814 return stack.Initialize.Add(&validateOpPutSlotType{}, middleware.After) 815} 816 817func addOpStartImportValidationMiddleware(stack *middleware.Stack) error { 818 return stack.Initialize.Add(&validateOpStartImport{}, middleware.After) 819} 820 821func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 822 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 823} 824 825func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 826 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 827} 828 829func validateCodeHook(v *types.CodeHook) error { 830 if v == nil { 831 return nil 832 } 833 invalidParams := smithy.InvalidParamsError{Context: "CodeHook"} 834 if v.Uri == nil { 835 invalidParams.Add(smithy.NewErrParamRequired("Uri")) 836 } 837 if v.MessageVersion == nil { 838 invalidParams.Add(smithy.NewErrParamRequired("MessageVersion")) 839 } 840 if invalidParams.Len() > 0 { 841 return invalidParams 842 } else { 843 return nil 844 } 845} 846 847func validateConversationLogsRequest(v *types.ConversationLogsRequest) error { 848 if v == nil { 849 return nil 850 } 851 invalidParams := smithy.InvalidParamsError{Context: "ConversationLogsRequest"} 852 if v.LogSettings == nil { 853 invalidParams.Add(smithy.NewErrParamRequired("LogSettings")) 854 } else if v.LogSettings != nil { 855 if err := validateLogSettingsRequestList(v.LogSettings); err != nil { 856 invalidParams.AddNested("LogSettings", err.(smithy.InvalidParamsError)) 857 } 858 } 859 if v.IamRoleArn == nil { 860 invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn")) 861 } 862 if invalidParams.Len() > 0 { 863 return invalidParams 864 } else { 865 return nil 866 } 867} 868 869func validateEnumerationValue(v *types.EnumerationValue) error { 870 if v == nil { 871 return nil 872 } 873 invalidParams := smithy.InvalidParamsError{Context: "EnumerationValue"} 874 if v.Value == nil { 875 invalidParams.Add(smithy.NewErrParamRequired("Value")) 876 } 877 if invalidParams.Len() > 0 { 878 return invalidParams 879 } else { 880 return nil 881 } 882} 883 884func validateEnumerationValues(v []types.EnumerationValue) error { 885 if v == nil { 886 return nil 887 } 888 invalidParams := smithy.InvalidParamsError{Context: "EnumerationValues"} 889 for i := range v { 890 if err := validateEnumerationValue(&v[i]); err != nil { 891 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 892 } 893 } 894 if invalidParams.Len() > 0 { 895 return invalidParams 896 } else { 897 return nil 898 } 899} 900 901func validateFollowUpPrompt(v *types.FollowUpPrompt) error { 902 if v == nil { 903 return nil 904 } 905 invalidParams := smithy.InvalidParamsError{Context: "FollowUpPrompt"} 906 if v.Prompt == nil { 907 invalidParams.Add(smithy.NewErrParamRequired("Prompt")) 908 } else if v.Prompt != nil { 909 if err := validatePrompt(v.Prompt); err != nil { 910 invalidParams.AddNested("Prompt", err.(smithy.InvalidParamsError)) 911 } 912 } 913 if v.RejectionStatement == nil { 914 invalidParams.Add(smithy.NewErrParamRequired("RejectionStatement")) 915 } else if v.RejectionStatement != nil { 916 if err := validateStatement(v.RejectionStatement); err != nil { 917 invalidParams.AddNested("RejectionStatement", err.(smithy.InvalidParamsError)) 918 } 919 } 920 if invalidParams.Len() > 0 { 921 return invalidParams 922 } else { 923 return nil 924 } 925} 926 927func validateFulfillmentActivity(v *types.FulfillmentActivity) error { 928 if v == nil { 929 return nil 930 } 931 invalidParams := smithy.InvalidParamsError{Context: "FulfillmentActivity"} 932 if len(v.Type) == 0 { 933 invalidParams.Add(smithy.NewErrParamRequired("Type")) 934 } 935 if v.CodeHook != nil { 936 if err := validateCodeHook(v.CodeHook); err != nil { 937 invalidParams.AddNested("CodeHook", err.(smithy.InvalidParamsError)) 938 } 939 } 940 if invalidParams.Len() > 0 { 941 return invalidParams 942 } else { 943 return nil 944 } 945} 946 947func validateInputContext(v *types.InputContext) error { 948 if v == nil { 949 return nil 950 } 951 invalidParams := smithy.InvalidParamsError{Context: "InputContext"} 952 if v.Name == nil { 953 invalidParams.Add(smithy.NewErrParamRequired("Name")) 954 } 955 if invalidParams.Len() > 0 { 956 return invalidParams 957 } else { 958 return nil 959 } 960} 961 962func validateInputContextList(v []types.InputContext) error { 963 if v == nil { 964 return nil 965 } 966 invalidParams := smithy.InvalidParamsError{Context: "InputContextList"} 967 for i := range v { 968 if err := validateInputContext(&v[i]); err != nil { 969 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 970 } 971 } 972 if invalidParams.Len() > 0 { 973 return invalidParams 974 } else { 975 return nil 976 } 977} 978 979func validateIntent(v *types.Intent) error { 980 if v == nil { 981 return nil 982 } 983 invalidParams := smithy.InvalidParamsError{Context: "Intent"} 984 if v.IntentName == nil { 985 invalidParams.Add(smithy.NewErrParamRequired("IntentName")) 986 } 987 if v.IntentVersion == nil { 988 invalidParams.Add(smithy.NewErrParamRequired("IntentVersion")) 989 } 990 if invalidParams.Len() > 0 { 991 return invalidParams 992 } else { 993 return nil 994 } 995} 996 997func validateIntentList(v []types.Intent) error { 998 if v == nil { 999 return nil 1000 } 1001 invalidParams := smithy.InvalidParamsError{Context: "IntentList"} 1002 for i := range v { 1003 if err := validateIntent(&v[i]); err != nil { 1004 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1005 } 1006 } 1007 if invalidParams.Len() > 0 { 1008 return invalidParams 1009 } else { 1010 return nil 1011 } 1012} 1013 1014func validateKendraConfiguration(v *types.KendraConfiguration) error { 1015 if v == nil { 1016 return nil 1017 } 1018 invalidParams := smithy.InvalidParamsError{Context: "KendraConfiguration"} 1019 if v.KendraIndex == nil { 1020 invalidParams.Add(smithy.NewErrParamRequired("KendraIndex")) 1021 } 1022 if v.Role == nil { 1023 invalidParams.Add(smithy.NewErrParamRequired("Role")) 1024 } 1025 if invalidParams.Len() > 0 { 1026 return invalidParams 1027 } else { 1028 return nil 1029 } 1030} 1031 1032func validateLogSettingsRequest(v *types.LogSettingsRequest) error { 1033 if v == nil { 1034 return nil 1035 } 1036 invalidParams := smithy.InvalidParamsError{Context: "LogSettingsRequest"} 1037 if len(v.LogType) == 0 { 1038 invalidParams.Add(smithy.NewErrParamRequired("LogType")) 1039 } 1040 if len(v.Destination) == 0 { 1041 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 1042 } 1043 if v.ResourceArn == nil { 1044 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1045 } 1046 if invalidParams.Len() > 0 { 1047 return invalidParams 1048 } else { 1049 return nil 1050 } 1051} 1052 1053func validateLogSettingsRequestList(v []types.LogSettingsRequest) error { 1054 if v == nil { 1055 return nil 1056 } 1057 invalidParams := smithy.InvalidParamsError{Context: "LogSettingsRequestList"} 1058 for i := range v { 1059 if err := validateLogSettingsRequest(&v[i]); err != nil { 1060 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1061 } 1062 } 1063 if invalidParams.Len() > 0 { 1064 return invalidParams 1065 } else { 1066 return nil 1067 } 1068} 1069 1070func validateMessage(v *types.Message) error { 1071 if v == nil { 1072 return nil 1073 } 1074 invalidParams := smithy.InvalidParamsError{Context: "Message"} 1075 if len(v.ContentType) == 0 { 1076 invalidParams.Add(smithy.NewErrParamRequired("ContentType")) 1077 } 1078 if v.Content == nil { 1079 invalidParams.Add(smithy.NewErrParamRequired("Content")) 1080 } 1081 if invalidParams.Len() > 0 { 1082 return invalidParams 1083 } else { 1084 return nil 1085 } 1086} 1087 1088func validateMessageList(v []types.Message) error { 1089 if v == nil { 1090 return nil 1091 } 1092 invalidParams := smithy.InvalidParamsError{Context: "MessageList"} 1093 for i := range v { 1094 if err := validateMessage(&v[i]); err != nil { 1095 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1096 } 1097 } 1098 if invalidParams.Len() > 0 { 1099 return invalidParams 1100 } else { 1101 return nil 1102 } 1103} 1104 1105func validateOutputContext(v *types.OutputContext) error { 1106 if v == nil { 1107 return nil 1108 } 1109 invalidParams := smithy.InvalidParamsError{Context: "OutputContext"} 1110 if v.Name == nil { 1111 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1112 } 1113 if v.TimeToLiveInSeconds == nil { 1114 invalidParams.Add(smithy.NewErrParamRequired("TimeToLiveInSeconds")) 1115 } 1116 if v.TurnsToLive == nil { 1117 invalidParams.Add(smithy.NewErrParamRequired("TurnsToLive")) 1118 } 1119 if invalidParams.Len() > 0 { 1120 return invalidParams 1121 } else { 1122 return nil 1123 } 1124} 1125 1126func validateOutputContextList(v []types.OutputContext) error { 1127 if v == nil { 1128 return nil 1129 } 1130 invalidParams := smithy.InvalidParamsError{Context: "OutputContextList"} 1131 for i := range v { 1132 if err := validateOutputContext(&v[i]); err != nil { 1133 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1134 } 1135 } 1136 if invalidParams.Len() > 0 { 1137 return invalidParams 1138 } else { 1139 return nil 1140 } 1141} 1142 1143func validatePrompt(v *types.Prompt) error { 1144 if v == nil { 1145 return nil 1146 } 1147 invalidParams := smithy.InvalidParamsError{Context: "Prompt"} 1148 if v.Messages == nil { 1149 invalidParams.Add(smithy.NewErrParamRequired("Messages")) 1150 } else if v.Messages != nil { 1151 if err := validateMessageList(v.Messages); err != nil { 1152 invalidParams.AddNested("Messages", err.(smithy.InvalidParamsError)) 1153 } 1154 } 1155 if v.MaxAttempts == nil { 1156 invalidParams.Add(smithy.NewErrParamRequired("MaxAttempts")) 1157 } 1158 if invalidParams.Len() > 0 { 1159 return invalidParams 1160 } else { 1161 return nil 1162 } 1163} 1164 1165func validateSlot(v *types.Slot) error { 1166 if v == nil { 1167 return nil 1168 } 1169 invalidParams := smithy.InvalidParamsError{Context: "Slot"} 1170 if v.Name == nil { 1171 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1172 } 1173 if len(v.SlotConstraint) == 0 { 1174 invalidParams.Add(smithy.NewErrParamRequired("SlotConstraint")) 1175 } 1176 if v.ValueElicitationPrompt != nil { 1177 if err := validatePrompt(v.ValueElicitationPrompt); err != nil { 1178 invalidParams.AddNested("ValueElicitationPrompt", err.(smithy.InvalidParamsError)) 1179 } 1180 } 1181 if v.DefaultValueSpec != nil { 1182 if err := validateSlotDefaultValueSpec(v.DefaultValueSpec); err != nil { 1183 invalidParams.AddNested("DefaultValueSpec", err.(smithy.InvalidParamsError)) 1184 } 1185 } 1186 if invalidParams.Len() > 0 { 1187 return invalidParams 1188 } else { 1189 return nil 1190 } 1191} 1192 1193func validateSlotDefaultValue(v *types.SlotDefaultValue) error { 1194 if v == nil { 1195 return nil 1196 } 1197 invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValue"} 1198 if v.DefaultValue == nil { 1199 invalidParams.Add(smithy.NewErrParamRequired("DefaultValue")) 1200 } 1201 if invalidParams.Len() > 0 { 1202 return invalidParams 1203 } else { 1204 return nil 1205 } 1206} 1207 1208func validateSlotDefaultValueList(v []types.SlotDefaultValue) error { 1209 if v == nil { 1210 return nil 1211 } 1212 invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValueList"} 1213 for i := range v { 1214 if err := validateSlotDefaultValue(&v[i]); err != nil { 1215 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1216 } 1217 } 1218 if invalidParams.Len() > 0 { 1219 return invalidParams 1220 } else { 1221 return nil 1222 } 1223} 1224 1225func validateSlotDefaultValueSpec(v *types.SlotDefaultValueSpec) error { 1226 if v == nil { 1227 return nil 1228 } 1229 invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValueSpec"} 1230 if v.DefaultValueList == nil { 1231 invalidParams.Add(smithy.NewErrParamRequired("DefaultValueList")) 1232 } else if v.DefaultValueList != nil { 1233 if err := validateSlotDefaultValueList(v.DefaultValueList); err != nil { 1234 invalidParams.AddNested("DefaultValueList", err.(smithy.InvalidParamsError)) 1235 } 1236 } 1237 if invalidParams.Len() > 0 { 1238 return invalidParams 1239 } else { 1240 return nil 1241 } 1242} 1243 1244func validateSlotList(v []types.Slot) error { 1245 if v == nil { 1246 return nil 1247 } 1248 invalidParams := smithy.InvalidParamsError{Context: "SlotList"} 1249 for i := range v { 1250 if err := validateSlot(&v[i]); err != nil { 1251 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1252 } 1253 } 1254 if invalidParams.Len() > 0 { 1255 return invalidParams 1256 } else { 1257 return nil 1258 } 1259} 1260 1261func validateSlotTypeConfiguration(v *types.SlotTypeConfiguration) error { 1262 if v == nil { 1263 return nil 1264 } 1265 invalidParams := smithy.InvalidParamsError{Context: "SlotTypeConfiguration"} 1266 if v.RegexConfiguration != nil { 1267 if err := validateSlotTypeRegexConfiguration(v.RegexConfiguration); err != nil { 1268 invalidParams.AddNested("RegexConfiguration", err.(smithy.InvalidParamsError)) 1269 } 1270 } 1271 if invalidParams.Len() > 0 { 1272 return invalidParams 1273 } else { 1274 return nil 1275 } 1276} 1277 1278func validateSlotTypeConfigurations(v []types.SlotTypeConfiguration) error { 1279 if v == nil { 1280 return nil 1281 } 1282 invalidParams := smithy.InvalidParamsError{Context: "SlotTypeConfigurations"} 1283 for i := range v { 1284 if err := validateSlotTypeConfiguration(&v[i]); err != nil { 1285 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1286 } 1287 } 1288 if invalidParams.Len() > 0 { 1289 return invalidParams 1290 } else { 1291 return nil 1292 } 1293} 1294 1295func validateSlotTypeRegexConfiguration(v *types.SlotTypeRegexConfiguration) error { 1296 if v == nil { 1297 return nil 1298 } 1299 invalidParams := smithy.InvalidParamsError{Context: "SlotTypeRegexConfiguration"} 1300 if v.Pattern == nil { 1301 invalidParams.Add(smithy.NewErrParamRequired("Pattern")) 1302 } 1303 if invalidParams.Len() > 0 { 1304 return invalidParams 1305 } else { 1306 return nil 1307 } 1308} 1309 1310func validateStatement(v *types.Statement) error { 1311 if v == nil { 1312 return nil 1313 } 1314 invalidParams := smithy.InvalidParamsError{Context: "Statement"} 1315 if v.Messages == nil { 1316 invalidParams.Add(smithy.NewErrParamRequired("Messages")) 1317 } else if v.Messages != nil { 1318 if err := validateMessageList(v.Messages); err != nil { 1319 invalidParams.AddNested("Messages", err.(smithy.InvalidParamsError)) 1320 } 1321 } 1322 if invalidParams.Len() > 0 { 1323 return invalidParams 1324 } else { 1325 return nil 1326 } 1327} 1328 1329func validateTag(v *types.Tag) error { 1330 if v == nil { 1331 return nil 1332 } 1333 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1334 if v.Key == nil { 1335 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1336 } 1337 if v.Value == nil { 1338 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1339 } 1340 if invalidParams.Len() > 0 { 1341 return invalidParams 1342 } else { 1343 return nil 1344 } 1345} 1346 1347func validateTagList(v []types.Tag) error { 1348 if v == nil { 1349 return nil 1350 } 1351 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1352 for i := range v { 1353 if err := validateTag(&v[i]); err != nil { 1354 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1355 } 1356 } 1357 if invalidParams.Len() > 0 { 1358 return invalidParams 1359 } else { 1360 return nil 1361 } 1362} 1363 1364func validateOpCreateBotVersionInput(v *CreateBotVersionInput) error { 1365 if v == nil { 1366 return nil 1367 } 1368 invalidParams := smithy.InvalidParamsError{Context: "CreateBotVersionInput"} 1369 if v.Name == nil { 1370 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1371 } 1372 if invalidParams.Len() > 0 { 1373 return invalidParams 1374 } else { 1375 return nil 1376 } 1377} 1378 1379func validateOpCreateIntentVersionInput(v *CreateIntentVersionInput) error { 1380 if v == nil { 1381 return nil 1382 } 1383 invalidParams := smithy.InvalidParamsError{Context: "CreateIntentVersionInput"} 1384 if v.Name == nil { 1385 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1386 } 1387 if invalidParams.Len() > 0 { 1388 return invalidParams 1389 } else { 1390 return nil 1391 } 1392} 1393 1394func validateOpCreateSlotTypeVersionInput(v *CreateSlotTypeVersionInput) error { 1395 if v == nil { 1396 return nil 1397 } 1398 invalidParams := smithy.InvalidParamsError{Context: "CreateSlotTypeVersionInput"} 1399 if v.Name == nil { 1400 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1401 } 1402 if invalidParams.Len() > 0 { 1403 return invalidParams 1404 } else { 1405 return nil 1406 } 1407} 1408 1409func validateOpDeleteBotAliasInput(v *DeleteBotAliasInput) error { 1410 if v == nil { 1411 return nil 1412 } 1413 invalidParams := smithy.InvalidParamsError{Context: "DeleteBotAliasInput"} 1414 if v.Name == nil { 1415 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1416 } 1417 if v.BotName == nil { 1418 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1419 } 1420 if invalidParams.Len() > 0 { 1421 return invalidParams 1422 } else { 1423 return nil 1424 } 1425} 1426 1427func validateOpDeleteBotChannelAssociationInput(v *DeleteBotChannelAssociationInput) error { 1428 if v == nil { 1429 return nil 1430 } 1431 invalidParams := smithy.InvalidParamsError{Context: "DeleteBotChannelAssociationInput"} 1432 if v.Name == nil { 1433 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1434 } 1435 if v.BotName == nil { 1436 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1437 } 1438 if v.BotAlias == nil { 1439 invalidParams.Add(smithy.NewErrParamRequired("BotAlias")) 1440 } 1441 if invalidParams.Len() > 0 { 1442 return invalidParams 1443 } else { 1444 return nil 1445 } 1446} 1447 1448func validateOpDeleteBotInput(v *DeleteBotInput) error { 1449 if v == nil { 1450 return nil 1451 } 1452 invalidParams := smithy.InvalidParamsError{Context: "DeleteBotInput"} 1453 if v.Name == nil { 1454 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1455 } 1456 if invalidParams.Len() > 0 { 1457 return invalidParams 1458 } else { 1459 return nil 1460 } 1461} 1462 1463func validateOpDeleteBotVersionInput(v *DeleteBotVersionInput) error { 1464 if v == nil { 1465 return nil 1466 } 1467 invalidParams := smithy.InvalidParamsError{Context: "DeleteBotVersionInput"} 1468 if v.Name == nil { 1469 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1470 } 1471 if v.Version == nil { 1472 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1473 } 1474 if invalidParams.Len() > 0 { 1475 return invalidParams 1476 } else { 1477 return nil 1478 } 1479} 1480 1481func validateOpDeleteIntentInput(v *DeleteIntentInput) error { 1482 if v == nil { 1483 return nil 1484 } 1485 invalidParams := smithy.InvalidParamsError{Context: "DeleteIntentInput"} 1486 if v.Name == nil { 1487 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1488 } 1489 if invalidParams.Len() > 0 { 1490 return invalidParams 1491 } else { 1492 return nil 1493 } 1494} 1495 1496func validateOpDeleteIntentVersionInput(v *DeleteIntentVersionInput) error { 1497 if v == nil { 1498 return nil 1499 } 1500 invalidParams := smithy.InvalidParamsError{Context: "DeleteIntentVersionInput"} 1501 if v.Name == nil { 1502 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1503 } 1504 if v.Version == nil { 1505 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1506 } 1507 if invalidParams.Len() > 0 { 1508 return invalidParams 1509 } else { 1510 return nil 1511 } 1512} 1513 1514func validateOpDeleteSlotTypeInput(v *DeleteSlotTypeInput) error { 1515 if v == nil { 1516 return nil 1517 } 1518 invalidParams := smithy.InvalidParamsError{Context: "DeleteSlotTypeInput"} 1519 if v.Name == nil { 1520 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1521 } 1522 if invalidParams.Len() > 0 { 1523 return invalidParams 1524 } else { 1525 return nil 1526 } 1527} 1528 1529func validateOpDeleteSlotTypeVersionInput(v *DeleteSlotTypeVersionInput) error { 1530 if v == nil { 1531 return nil 1532 } 1533 invalidParams := smithy.InvalidParamsError{Context: "DeleteSlotTypeVersionInput"} 1534 if v.Name == nil { 1535 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1536 } 1537 if v.Version == nil { 1538 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1539 } 1540 if invalidParams.Len() > 0 { 1541 return invalidParams 1542 } else { 1543 return nil 1544 } 1545} 1546 1547func validateOpDeleteUtterancesInput(v *DeleteUtterancesInput) error { 1548 if v == nil { 1549 return nil 1550 } 1551 invalidParams := smithy.InvalidParamsError{Context: "DeleteUtterancesInput"} 1552 if v.BotName == nil { 1553 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1554 } 1555 if v.UserId == nil { 1556 invalidParams.Add(smithy.NewErrParamRequired("UserId")) 1557 } 1558 if invalidParams.Len() > 0 { 1559 return invalidParams 1560 } else { 1561 return nil 1562 } 1563} 1564 1565func validateOpGetBotAliasesInput(v *GetBotAliasesInput) error { 1566 if v == nil { 1567 return nil 1568 } 1569 invalidParams := smithy.InvalidParamsError{Context: "GetBotAliasesInput"} 1570 if v.BotName == nil { 1571 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1572 } 1573 if invalidParams.Len() > 0 { 1574 return invalidParams 1575 } else { 1576 return nil 1577 } 1578} 1579 1580func validateOpGetBotAliasInput(v *GetBotAliasInput) error { 1581 if v == nil { 1582 return nil 1583 } 1584 invalidParams := smithy.InvalidParamsError{Context: "GetBotAliasInput"} 1585 if v.Name == nil { 1586 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1587 } 1588 if v.BotName == nil { 1589 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1590 } 1591 if invalidParams.Len() > 0 { 1592 return invalidParams 1593 } else { 1594 return nil 1595 } 1596} 1597 1598func validateOpGetBotChannelAssociationInput(v *GetBotChannelAssociationInput) error { 1599 if v == nil { 1600 return nil 1601 } 1602 invalidParams := smithy.InvalidParamsError{Context: "GetBotChannelAssociationInput"} 1603 if v.Name == nil { 1604 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1605 } 1606 if v.BotName == nil { 1607 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1608 } 1609 if v.BotAlias == nil { 1610 invalidParams.Add(smithy.NewErrParamRequired("BotAlias")) 1611 } 1612 if invalidParams.Len() > 0 { 1613 return invalidParams 1614 } else { 1615 return nil 1616 } 1617} 1618 1619func validateOpGetBotChannelAssociationsInput(v *GetBotChannelAssociationsInput) error { 1620 if v == nil { 1621 return nil 1622 } 1623 invalidParams := smithy.InvalidParamsError{Context: "GetBotChannelAssociationsInput"} 1624 if v.BotName == nil { 1625 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1626 } 1627 if v.BotAlias == nil { 1628 invalidParams.Add(smithy.NewErrParamRequired("BotAlias")) 1629 } 1630 if invalidParams.Len() > 0 { 1631 return invalidParams 1632 } else { 1633 return nil 1634 } 1635} 1636 1637func validateOpGetBotInput(v *GetBotInput) error { 1638 if v == nil { 1639 return nil 1640 } 1641 invalidParams := smithy.InvalidParamsError{Context: "GetBotInput"} 1642 if v.Name == nil { 1643 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1644 } 1645 if v.VersionOrAlias == nil { 1646 invalidParams.Add(smithy.NewErrParamRequired("VersionOrAlias")) 1647 } 1648 if invalidParams.Len() > 0 { 1649 return invalidParams 1650 } else { 1651 return nil 1652 } 1653} 1654 1655func validateOpGetBotVersionsInput(v *GetBotVersionsInput) error { 1656 if v == nil { 1657 return nil 1658 } 1659 invalidParams := smithy.InvalidParamsError{Context: "GetBotVersionsInput"} 1660 if v.Name == nil { 1661 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1662 } 1663 if invalidParams.Len() > 0 { 1664 return invalidParams 1665 } else { 1666 return nil 1667 } 1668} 1669 1670func validateOpGetBuiltinIntentInput(v *GetBuiltinIntentInput) error { 1671 if v == nil { 1672 return nil 1673 } 1674 invalidParams := smithy.InvalidParamsError{Context: "GetBuiltinIntentInput"} 1675 if v.Signature == nil { 1676 invalidParams.Add(smithy.NewErrParamRequired("Signature")) 1677 } 1678 if invalidParams.Len() > 0 { 1679 return invalidParams 1680 } else { 1681 return nil 1682 } 1683} 1684 1685func validateOpGetExportInput(v *GetExportInput) error { 1686 if v == nil { 1687 return nil 1688 } 1689 invalidParams := smithy.InvalidParamsError{Context: "GetExportInput"} 1690 if v.Name == nil { 1691 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1692 } 1693 if v.Version == nil { 1694 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1695 } 1696 if len(v.ResourceType) == 0 { 1697 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 1698 } 1699 if len(v.ExportType) == 0 { 1700 invalidParams.Add(smithy.NewErrParamRequired("ExportType")) 1701 } 1702 if invalidParams.Len() > 0 { 1703 return invalidParams 1704 } else { 1705 return nil 1706 } 1707} 1708 1709func validateOpGetImportInput(v *GetImportInput) error { 1710 if v == nil { 1711 return nil 1712 } 1713 invalidParams := smithy.InvalidParamsError{Context: "GetImportInput"} 1714 if v.ImportId == nil { 1715 invalidParams.Add(smithy.NewErrParamRequired("ImportId")) 1716 } 1717 if invalidParams.Len() > 0 { 1718 return invalidParams 1719 } else { 1720 return nil 1721 } 1722} 1723 1724func validateOpGetIntentInput(v *GetIntentInput) error { 1725 if v == nil { 1726 return nil 1727 } 1728 invalidParams := smithy.InvalidParamsError{Context: "GetIntentInput"} 1729 if v.Name == nil { 1730 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1731 } 1732 if v.Version == nil { 1733 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1734 } 1735 if invalidParams.Len() > 0 { 1736 return invalidParams 1737 } else { 1738 return nil 1739 } 1740} 1741 1742func validateOpGetIntentVersionsInput(v *GetIntentVersionsInput) error { 1743 if v == nil { 1744 return nil 1745 } 1746 invalidParams := smithy.InvalidParamsError{Context: "GetIntentVersionsInput"} 1747 if v.Name == nil { 1748 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1749 } 1750 if invalidParams.Len() > 0 { 1751 return invalidParams 1752 } else { 1753 return nil 1754 } 1755} 1756 1757func validateOpGetSlotTypeInput(v *GetSlotTypeInput) error { 1758 if v == nil { 1759 return nil 1760 } 1761 invalidParams := smithy.InvalidParamsError{Context: "GetSlotTypeInput"} 1762 if v.Name == nil { 1763 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1764 } 1765 if v.Version == nil { 1766 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1767 } 1768 if invalidParams.Len() > 0 { 1769 return invalidParams 1770 } else { 1771 return nil 1772 } 1773} 1774 1775func validateOpGetSlotTypeVersionsInput(v *GetSlotTypeVersionsInput) error { 1776 if v == nil { 1777 return nil 1778 } 1779 invalidParams := smithy.InvalidParamsError{Context: "GetSlotTypeVersionsInput"} 1780 if v.Name == nil { 1781 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1782 } 1783 if invalidParams.Len() > 0 { 1784 return invalidParams 1785 } else { 1786 return nil 1787 } 1788} 1789 1790func validateOpGetUtterancesViewInput(v *GetUtterancesViewInput) error { 1791 if v == nil { 1792 return nil 1793 } 1794 invalidParams := smithy.InvalidParamsError{Context: "GetUtterancesViewInput"} 1795 if v.BotName == nil { 1796 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1797 } 1798 if v.BotVersions == nil { 1799 invalidParams.Add(smithy.NewErrParamRequired("BotVersions")) 1800 } 1801 if len(v.StatusType) == 0 { 1802 invalidParams.Add(smithy.NewErrParamRequired("StatusType")) 1803 } 1804 if invalidParams.Len() > 0 { 1805 return invalidParams 1806 } else { 1807 return nil 1808 } 1809} 1810 1811func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1812 if v == nil { 1813 return nil 1814 } 1815 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1816 if v.ResourceArn == nil { 1817 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1818 } 1819 if invalidParams.Len() > 0 { 1820 return invalidParams 1821 } else { 1822 return nil 1823 } 1824} 1825 1826func validateOpPutBotAliasInput(v *PutBotAliasInput) error { 1827 if v == nil { 1828 return nil 1829 } 1830 invalidParams := smithy.InvalidParamsError{Context: "PutBotAliasInput"} 1831 if v.Name == nil { 1832 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1833 } 1834 if v.BotVersion == nil { 1835 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 1836 } 1837 if v.BotName == nil { 1838 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 1839 } 1840 if v.ConversationLogs != nil { 1841 if err := validateConversationLogsRequest(v.ConversationLogs); err != nil { 1842 invalidParams.AddNested("ConversationLogs", err.(smithy.InvalidParamsError)) 1843 } 1844 } 1845 if v.Tags != nil { 1846 if err := validateTagList(v.Tags); err != nil { 1847 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1848 } 1849 } 1850 if invalidParams.Len() > 0 { 1851 return invalidParams 1852 } else { 1853 return nil 1854 } 1855} 1856 1857func validateOpPutBotInput(v *PutBotInput) error { 1858 if v == nil { 1859 return nil 1860 } 1861 invalidParams := smithy.InvalidParamsError{Context: "PutBotInput"} 1862 if v.Name == nil { 1863 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1864 } 1865 if v.Intents != nil { 1866 if err := validateIntentList(v.Intents); err != nil { 1867 invalidParams.AddNested("Intents", err.(smithy.InvalidParamsError)) 1868 } 1869 } 1870 if v.ClarificationPrompt != nil { 1871 if err := validatePrompt(v.ClarificationPrompt); err != nil { 1872 invalidParams.AddNested("ClarificationPrompt", err.(smithy.InvalidParamsError)) 1873 } 1874 } 1875 if v.AbortStatement != nil { 1876 if err := validateStatement(v.AbortStatement); err != nil { 1877 invalidParams.AddNested("AbortStatement", err.(smithy.InvalidParamsError)) 1878 } 1879 } 1880 if len(v.Locale) == 0 { 1881 invalidParams.Add(smithy.NewErrParamRequired("Locale")) 1882 } 1883 if v.ChildDirected == nil { 1884 invalidParams.Add(smithy.NewErrParamRequired("ChildDirected")) 1885 } 1886 if v.Tags != nil { 1887 if err := validateTagList(v.Tags); err != nil { 1888 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1889 } 1890 } 1891 if invalidParams.Len() > 0 { 1892 return invalidParams 1893 } else { 1894 return nil 1895 } 1896} 1897 1898func validateOpPutIntentInput(v *PutIntentInput) error { 1899 if v == nil { 1900 return nil 1901 } 1902 invalidParams := smithy.InvalidParamsError{Context: "PutIntentInput"} 1903 if v.Name == nil { 1904 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1905 } 1906 if v.Slots != nil { 1907 if err := validateSlotList(v.Slots); err != nil { 1908 invalidParams.AddNested("Slots", err.(smithy.InvalidParamsError)) 1909 } 1910 } 1911 if v.ConfirmationPrompt != nil { 1912 if err := validatePrompt(v.ConfirmationPrompt); err != nil { 1913 invalidParams.AddNested("ConfirmationPrompt", err.(smithy.InvalidParamsError)) 1914 } 1915 } 1916 if v.RejectionStatement != nil { 1917 if err := validateStatement(v.RejectionStatement); err != nil { 1918 invalidParams.AddNested("RejectionStatement", err.(smithy.InvalidParamsError)) 1919 } 1920 } 1921 if v.FollowUpPrompt != nil { 1922 if err := validateFollowUpPrompt(v.FollowUpPrompt); err != nil { 1923 invalidParams.AddNested("FollowUpPrompt", err.(smithy.InvalidParamsError)) 1924 } 1925 } 1926 if v.ConclusionStatement != nil { 1927 if err := validateStatement(v.ConclusionStatement); err != nil { 1928 invalidParams.AddNested("ConclusionStatement", err.(smithy.InvalidParamsError)) 1929 } 1930 } 1931 if v.DialogCodeHook != nil { 1932 if err := validateCodeHook(v.DialogCodeHook); err != nil { 1933 invalidParams.AddNested("DialogCodeHook", err.(smithy.InvalidParamsError)) 1934 } 1935 } 1936 if v.FulfillmentActivity != nil { 1937 if err := validateFulfillmentActivity(v.FulfillmentActivity); err != nil { 1938 invalidParams.AddNested("FulfillmentActivity", err.(smithy.InvalidParamsError)) 1939 } 1940 } 1941 if v.KendraConfiguration != nil { 1942 if err := validateKendraConfiguration(v.KendraConfiguration); err != nil { 1943 invalidParams.AddNested("KendraConfiguration", err.(smithy.InvalidParamsError)) 1944 } 1945 } 1946 if v.InputContexts != nil { 1947 if err := validateInputContextList(v.InputContexts); err != nil { 1948 invalidParams.AddNested("InputContexts", err.(smithy.InvalidParamsError)) 1949 } 1950 } 1951 if v.OutputContexts != nil { 1952 if err := validateOutputContextList(v.OutputContexts); err != nil { 1953 invalidParams.AddNested("OutputContexts", err.(smithy.InvalidParamsError)) 1954 } 1955 } 1956 if invalidParams.Len() > 0 { 1957 return invalidParams 1958 } else { 1959 return nil 1960 } 1961} 1962 1963func validateOpPutSlotTypeInput(v *PutSlotTypeInput) error { 1964 if v == nil { 1965 return nil 1966 } 1967 invalidParams := smithy.InvalidParamsError{Context: "PutSlotTypeInput"} 1968 if v.Name == nil { 1969 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1970 } 1971 if v.EnumerationValues != nil { 1972 if err := validateEnumerationValues(v.EnumerationValues); err != nil { 1973 invalidParams.AddNested("EnumerationValues", err.(smithy.InvalidParamsError)) 1974 } 1975 } 1976 if v.SlotTypeConfigurations != nil { 1977 if err := validateSlotTypeConfigurations(v.SlotTypeConfigurations); err != nil { 1978 invalidParams.AddNested("SlotTypeConfigurations", err.(smithy.InvalidParamsError)) 1979 } 1980 } 1981 if invalidParams.Len() > 0 { 1982 return invalidParams 1983 } else { 1984 return nil 1985 } 1986} 1987 1988func validateOpStartImportInput(v *StartImportInput) error { 1989 if v == nil { 1990 return nil 1991 } 1992 invalidParams := smithy.InvalidParamsError{Context: "StartImportInput"} 1993 if v.Payload == nil { 1994 invalidParams.Add(smithy.NewErrParamRequired("Payload")) 1995 } 1996 if len(v.ResourceType) == 0 { 1997 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 1998 } 1999 if len(v.MergeStrategy) == 0 { 2000 invalidParams.Add(smithy.NewErrParamRequired("MergeStrategy")) 2001 } 2002 if v.Tags != nil { 2003 if err := validateTagList(v.Tags); err != nil { 2004 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2005 } 2006 } 2007 if invalidParams.Len() > 0 { 2008 return invalidParams 2009 } else { 2010 return nil 2011 } 2012} 2013 2014func validateOpTagResourceInput(v *TagResourceInput) error { 2015 if v == nil { 2016 return nil 2017 } 2018 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2019 if v.ResourceArn == nil { 2020 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2021 } 2022 if v.Tags == nil { 2023 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2024 } else if v.Tags != nil { 2025 if err := validateTagList(v.Tags); err != nil { 2026 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2027 } 2028 } 2029 if invalidParams.Len() > 0 { 2030 return invalidParams 2031 } else { 2032 return nil 2033 } 2034} 2035 2036func validateOpUntagResourceInput(v *UntagResourceInput) error { 2037 if v == nil { 2038 return nil 2039 } 2040 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2041 if v.ResourceArn == nil { 2042 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2043 } 2044 if v.TagKeys == nil { 2045 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2046 } 2047 if invalidParams.Len() > 0 { 2048 return invalidParams 2049 } else { 2050 return nil 2051 } 2052} 2053