1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package lexmodelsv2 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/lexmodelsv2/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpBuildBotLocale struct { 14} 15 16func (*validateOpBuildBotLocale) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpBuildBotLocale) 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.(*BuildBotLocaleInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpBuildBotLocaleInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateBotAlias struct { 34} 35 36func (*validateOpCreateBotAlias) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateBotAlias) 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.(*CreateBotAliasInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateBotAliasInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateBot struct { 54} 55 56func (*validateOpCreateBot) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateBot) 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.(*CreateBotInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateBotInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateBotLocale struct { 74} 75 76func (*validateOpCreateBotLocale) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateBotLocale) 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.(*CreateBotLocaleInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateBotLocaleInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateBotVersion struct { 94} 95 96func (*validateOpCreateBotVersion) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateBotVersion) 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.(*CreateBotVersionInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateBotVersionInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateIntent struct { 114} 115 116func (*validateOpCreateIntent) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateIntent) 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.(*CreateIntentInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateIntentInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateSlot struct { 134} 135 136func (*validateOpCreateSlot) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateSlot) 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.(*CreateSlotInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateSlotInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreateSlotType struct { 154} 155 156func (*validateOpCreateSlotType) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreateSlotType) 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.(*CreateSlotTypeInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreateSlotTypeInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteBotAlias struct { 174} 175 176func (*validateOpDeleteBotAlias) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteBotAlias) 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.(*DeleteBotAliasInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteBotAliasInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteBot struct { 194} 195 196func (*validateOpDeleteBot) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteBot) 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.(*DeleteBotInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteBotInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteBotLocale struct { 214} 215 216func (*validateOpDeleteBotLocale) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteBotLocale) 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.(*DeleteBotLocaleInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteBotLocaleInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteBotVersion struct { 234} 235 236func (*validateOpDeleteBotVersion) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteBotVersion) 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.(*DeleteBotVersionInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteBotVersionInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteIntent struct { 254} 255 256func (*validateOpDeleteIntent) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteIntent) 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.(*DeleteIntentInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteIntentInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeleteSlot struct { 274} 275 276func (*validateOpDeleteSlot) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeleteSlot) 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.(*DeleteSlotInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeleteSlotInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDeleteSlotType struct { 294} 295 296func (*validateOpDeleteSlotType) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDeleteSlotType) 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.(*DeleteSlotTypeInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDeleteSlotTypeInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDescribeBotAlias struct { 314} 315 316func (*validateOpDescribeBotAlias) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDescribeBotAlias) 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.(*DescribeBotAliasInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDescribeBotAliasInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDescribeBot struct { 334} 335 336func (*validateOpDescribeBot) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDescribeBot) 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.(*DescribeBotInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDescribeBotInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDescribeBotLocale struct { 354} 355 356func (*validateOpDescribeBotLocale) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDescribeBotLocale) 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.(*DescribeBotLocaleInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDescribeBotLocaleInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDescribeBotVersion struct { 374} 375 376func (*validateOpDescribeBotVersion) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDescribeBotVersion) 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.(*DescribeBotVersionInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDescribeBotVersionInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribeIntent struct { 394} 395 396func (*validateOpDescribeIntent) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribeIntent) 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.(*DescribeIntentInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribeIntentInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDescribeSlot struct { 414} 415 416func (*validateOpDescribeSlot) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDescribeSlot) 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.(*DescribeSlotInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDescribeSlotInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDescribeSlotType struct { 434} 435 436func (*validateOpDescribeSlotType) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDescribeSlotType) 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.(*DescribeSlotTypeInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDescribeSlotTypeInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpListBotAliases struct { 454} 455 456func (*validateOpListBotAliases) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpListBotAliases) 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.(*ListBotAliasesInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpListBotAliasesInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpListBotLocales struct { 474} 475 476func (*validateOpListBotLocales) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpListBotLocales) 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.(*ListBotLocalesInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpListBotLocalesInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpListBots struct { 494} 495 496func (*validateOpListBots) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpListBots) 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.(*ListBotsInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpListBotsInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpListBotVersions struct { 514} 515 516func (*validateOpListBotVersions) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpListBotVersions) 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.(*ListBotVersionsInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpListBotVersionsInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpListBuiltInIntents struct { 534} 535 536func (*validateOpListBuiltInIntents) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpListBuiltInIntents) 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.(*ListBuiltInIntentsInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpListBuiltInIntentsInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpListBuiltInSlotTypes struct { 554} 555 556func (*validateOpListBuiltInSlotTypes) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpListBuiltInSlotTypes) 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.(*ListBuiltInSlotTypesInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpListBuiltInSlotTypesInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpListIntents struct { 574} 575 576func (*validateOpListIntents) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpListIntents) 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.(*ListIntentsInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpListIntentsInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpListSlots struct { 594} 595 596func (*validateOpListSlots) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpListSlots) 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.(*ListSlotsInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpListSlotsInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpListSlotTypes struct { 614} 615 616func (*validateOpListSlotTypes) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpListSlotTypes) 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.(*ListSlotTypesInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpListSlotTypesInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpListTagsForResource struct { 634} 635 636func (*validateOpListTagsForResource) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpListTagsForResourceInput(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 693type validateOpUpdateBotAlias struct { 694} 695 696func (*validateOpUpdateBotAlias) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpUpdateBotAlias) 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.(*UpdateBotAliasInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpUpdateBotAliasInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpUpdateBot struct { 714} 715 716func (*validateOpUpdateBot) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpUpdateBot) 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.(*UpdateBotInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpUpdateBotInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpUpdateBotLocale struct { 734} 735 736func (*validateOpUpdateBotLocale) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpUpdateBotLocale) 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.(*UpdateBotLocaleInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpUpdateBotLocaleInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpUpdateIntent struct { 754} 755 756func (*validateOpUpdateIntent) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpUpdateIntent) 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.(*UpdateIntentInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpUpdateIntentInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpUpdateSlot struct { 774} 775 776func (*validateOpUpdateSlot) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpUpdateSlot) 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.(*UpdateSlotInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpUpdateSlotInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpUpdateSlotType struct { 794} 795 796func (*validateOpUpdateSlotType) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpUpdateSlotType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 802) { 803 input, ok := in.Parameters.(*UpdateSlotTypeInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpUpdateSlotTypeInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813func addOpBuildBotLocaleValidationMiddleware(stack *middleware.Stack) error { 814 return stack.Initialize.Add(&validateOpBuildBotLocale{}, middleware.After) 815} 816 817func addOpCreateBotAliasValidationMiddleware(stack *middleware.Stack) error { 818 return stack.Initialize.Add(&validateOpCreateBotAlias{}, middleware.After) 819} 820 821func addOpCreateBotValidationMiddleware(stack *middleware.Stack) error { 822 return stack.Initialize.Add(&validateOpCreateBot{}, middleware.After) 823} 824 825func addOpCreateBotLocaleValidationMiddleware(stack *middleware.Stack) error { 826 return stack.Initialize.Add(&validateOpCreateBotLocale{}, middleware.After) 827} 828 829func addOpCreateBotVersionValidationMiddleware(stack *middleware.Stack) error { 830 return stack.Initialize.Add(&validateOpCreateBotVersion{}, middleware.After) 831} 832 833func addOpCreateIntentValidationMiddleware(stack *middleware.Stack) error { 834 return stack.Initialize.Add(&validateOpCreateIntent{}, middleware.After) 835} 836 837func addOpCreateSlotValidationMiddleware(stack *middleware.Stack) error { 838 return stack.Initialize.Add(&validateOpCreateSlot{}, middleware.After) 839} 840 841func addOpCreateSlotTypeValidationMiddleware(stack *middleware.Stack) error { 842 return stack.Initialize.Add(&validateOpCreateSlotType{}, middleware.After) 843} 844 845func addOpDeleteBotAliasValidationMiddleware(stack *middleware.Stack) error { 846 return stack.Initialize.Add(&validateOpDeleteBotAlias{}, middleware.After) 847} 848 849func addOpDeleteBotValidationMiddleware(stack *middleware.Stack) error { 850 return stack.Initialize.Add(&validateOpDeleteBot{}, middleware.After) 851} 852 853func addOpDeleteBotLocaleValidationMiddleware(stack *middleware.Stack) error { 854 return stack.Initialize.Add(&validateOpDeleteBotLocale{}, middleware.After) 855} 856 857func addOpDeleteBotVersionValidationMiddleware(stack *middleware.Stack) error { 858 return stack.Initialize.Add(&validateOpDeleteBotVersion{}, middleware.After) 859} 860 861func addOpDeleteIntentValidationMiddleware(stack *middleware.Stack) error { 862 return stack.Initialize.Add(&validateOpDeleteIntent{}, middleware.After) 863} 864 865func addOpDeleteSlotValidationMiddleware(stack *middleware.Stack) error { 866 return stack.Initialize.Add(&validateOpDeleteSlot{}, middleware.After) 867} 868 869func addOpDeleteSlotTypeValidationMiddleware(stack *middleware.Stack) error { 870 return stack.Initialize.Add(&validateOpDeleteSlotType{}, middleware.After) 871} 872 873func addOpDescribeBotAliasValidationMiddleware(stack *middleware.Stack) error { 874 return stack.Initialize.Add(&validateOpDescribeBotAlias{}, middleware.After) 875} 876 877func addOpDescribeBotValidationMiddleware(stack *middleware.Stack) error { 878 return stack.Initialize.Add(&validateOpDescribeBot{}, middleware.After) 879} 880 881func addOpDescribeBotLocaleValidationMiddleware(stack *middleware.Stack) error { 882 return stack.Initialize.Add(&validateOpDescribeBotLocale{}, middleware.After) 883} 884 885func addOpDescribeBotVersionValidationMiddleware(stack *middleware.Stack) error { 886 return stack.Initialize.Add(&validateOpDescribeBotVersion{}, middleware.After) 887} 888 889func addOpDescribeIntentValidationMiddleware(stack *middleware.Stack) error { 890 return stack.Initialize.Add(&validateOpDescribeIntent{}, middleware.After) 891} 892 893func addOpDescribeSlotValidationMiddleware(stack *middleware.Stack) error { 894 return stack.Initialize.Add(&validateOpDescribeSlot{}, middleware.After) 895} 896 897func addOpDescribeSlotTypeValidationMiddleware(stack *middleware.Stack) error { 898 return stack.Initialize.Add(&validateOpDescribeSlotType{}, middleware.After) 899} 900 901func addOpListBotAliasesValidationMiddleware(stack *middleware.Stack) error { 902 return stack.Initialize.Add(&validateOpListBotAliases{}, middleware.After) 903} 904 905func addOpListBotLocalesValidationMiddleware(stack *middleware.Stack) error { 906 return stack.Initialize.Add(&validateOpListBotLocales{}, middleware.After) 907} 908 909func addOpListBotsValidationMiddleware(stack *middleware.Stack) error { 910 return stack.Initialize.Add(&validateOpListBots{}, middleware.After) 911} 912 913func addOpListBotVersionsValidationMiddleware(stack *middleware.Stack) error { 914 return stack.Initialize.Add(&validateOpListBotVersions{}, middleware.After) 915} 916 917func addOpListBuiltInIntentsValidationMiddleware(stack *middleware.Stack) error { 918 return stack.Initialize.Add(&validateOpListBuiltInIntents{}, middleware.After) 919} 920 921func addOpListBuiltInSlotTypesValidationMiddleware(stack *middleware.Stack) error { 922 return stack.Initialize.Add(&validateOpListBuiltInSlotTypes{}, middleware.After) 923} 924 925func addOpListIntentsValidationMiddleware(stack *middleware.Stack) error { 926 return stack.Initialize.Add(&validateOpListIntents{}, middleware.After) 927} 928 929func addOpListSlotsValidationMiddleware(stack *middleware.Stack) error { 930 return stack.Initialize.Add(&validateOpListSlots{}, middleware.After) 931} 932 933func addOpListSlotTypesValidationMiddleware(stack *middleware.Stack) error { 934 return stack.Initialize.Add(&validateOpListSlotTypes{}, middleware.After) 935} 936 937func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 938 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 939} 940 941func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 942 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 943} 944 945func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 946 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 947} 948 949func addOpUpdateBotAliasValidationMiddleware(stack *middleware.Stack) error { 950 return stack.Initialize.Add(&validateOpUpdateBotAlias{}, middleware.After) 951} 952 953func addOpUpdateBotValidationMiddleware(stack *middleware.Stack) error { 954 return stack.Initialize.Add(&validateOpUpdateBot{}, middleware.After) 955} 956 957func addOpUpdateBotLocaleValidationMiddleware(stack *middleware.Stack) error { 958 return stack.Initialize.Add(&validateOpUpdateBotLocale{}, middleware.After) 959} 960 961func addOpUpdateIntentValidationMiddleware(stack *middleware.Stack) error { 962 return stack.Initialize.Add(&validateOpUpdateIntent{}, middleware.After) 963} 964 965func addOpUpdateSlotValidationMiddleware(stack *middleware.Stack) error { 966 return stack.Initialize.Add(&validateOpUpdateSlot{}, middleware.After) 967} 968 969func addOpUpdateSlotTypeValidationMiddleware(stack *middleware.Stack) error { 970 return stack.Initialize.Add(&validateOpUpdateSlotType{}, middleware.After) 971} 972 973func validateAudioLogDestination(v *types.AudioLogDestination) error { 974 if v == nil { 975 return nil 976 } 977 invalidParams := smithy.InvalidParamsError{Context: "AudioLogDestination"} 978 if v.S3Bucket == nil { 979 invalidParams.Add(smithy.NewErrParamRequired("S3Bucket")) 980 } else if v.S3Bucket != nil { 981 if err := validateS3BucketLogDestination(v.S3Bucket); err != nil { 982 invalidParams.AddNested("S3Bucket", err.(smithy.InvalidParamsError)) 983 } 984 } 985 if invalidParams.Len() > 0 { 986 return invalidParams 987 } else { 988 return nil 989 } 990} 991 992func validateAudioLogSetting(v *types.AudioLogSetting) error { 993 if v == nil { 994 return nil 995 } 996 invalidParams := smithy.InvalidParamsError{Context: "AudioLogSetting"} 997 if v.Destination == nil { 998 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 999 } else if v.Destination != nil { 1000 if err := validateAudioLogDestination(v.Destination); err != nil { 1001 invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError)) 1002 } 1003 } 1004 if invalidParams.Len() > 0 { 1005 return invalidParams 1006 } else { 1007 return nil 1008 } 1009} 1010 1011func validateAudioLogSettingsList(v []types.AudioLogSetting) error { 1012 if v == nil { 1013 return nil 1014 } 1015 invalidParams := smithy.InvalidParamsError{Context: "AudioLogSettingsList"} 1016 for i := range v { 1017 if err := validateAudioLogSetting(&v[i]); err != nil { 1018 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1019 } 1020 } 1021 if invalidParams.Len() > 0 { 1022 return invalidParams 1023 } else { 1024 return nil 1025 } 1026} 1027 1028func validateBotAliasLocaleSettings(v *types.BotAliasLocaleSettings) error { 1029 if v == nil { 1030 return nil 1031 } 1032 invalidParams := smithy.InvalidParamsError{Context: "BotAliasLocaleSettings"} 1033 if v.CodeHookSpecification != nil { 1034 if err := validateCodeHookSpecification(v.CodeHookSpecification); err != nil { 1035 invalidParams.AddNested("CodeHookSpecification", err.(smithy.InvalidParamsError)) 1036 } 1037 } 1038 if invalidParams.Len() > 0 { 1039 return invalidParams 1040 } else { 1041 return nil 1042 } 1043} 1044 1045func validateBotAliasLocaleSettingsMap(v map[string]types.BotAliasLocaleSettings) error { 1046 if v == nil { 1047 return nil 1048 } 1049 invalidParams := smithy.InvalidParamsError{Context: "BotAliasLocaleSettingsMap"} 1050 for key := range v { 1051 value := v[key] 1052 if err := validateBotAliasLocaleSettings(&value); err != nil { 1053 invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError)) 1054 } 1055 } 1056 if invalidParams.Len() > 0 { 1057 return invalidParams 1058 } else { 1059 return nil 1060 } 1061} 1062 1063func validateBotFilter(v *types.BotFilter) error { 1064 if v == nil { 1065 return nil 1066 } 1067 invalidParams := smithy.InvalidParamsError{Context: "BotFilter"} 1068 if len(v.Name) == 0 { 1069 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1070 } 1071 if v.Values == nil { 1072 invalidParams.Add(smithy.NewErrParamRequired("Values")) 1073 } 1074 if len(v.Operator) == 0 { 1075 invalidParams.Add(smithy.NewErrParamRequired("Operator")) 1076 } 1077 if invalidParams.Len() > 0 { 1078 return invalidParams 1079 } else { 1080 return nil 1081 } 1082} 1083 1084func validateBotFilters(v []types.BotFilter) error { 1085 if v == nil { 1086 return nil 1087 } 1088 invalidParams := smithy.InvalidParamsError{Context: "BotFilters"} 1089 for i := range v { 1090 if err := validateBotFilter(&v[i]); err != nil { 1091 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1092 } 1093 } 1094 if invalidParams.Len() > 0 { 1095 return invalidParams 1096 } else { 1097 return nil 1098 } 1099} 1100 1101func validateBotLocaleFilter(v *types.BotLocaleFilter) error { 1102 if v == nil { 1103 return nil 1104 } 1105 invalidParams := smithy.InvalidParamsError{Context: "BotLocaleFilter"} 1106 if len(v.Name) == 0 { 1107 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1108 } 1109 if v.Values == nil { 1110 invalidParams.Add(smithy.NewErrParamRequired("Values")) 1111 } 1112 if len(v.Operator) == 0 { 1113 invalidParams.Add(smithy.NewErrParamRequired("Operator")) 1114 } 1115 if invalidParams.Len() > 0 { 1116 return invalidParams 1117 } else { 1118 return nil 1119 } 1120} 1121 1122func validateBotLocaleFilters(v []types.BotLocaleFilter) error { 1123 if v == nil { 1124 return nil 1125 } 1126 invalidParams := smithy.InvalidParamsError{Context: "BotLocaleFilters"} 1127 for i := range v { 1128 if err := validateBotLocaleFilter(&v[i]); err != nil { 1129 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1130 } 1131 } 1132 if invalidParams.Len() > 0 { 1133 return invalidParams 1134 } else { 1135 return nil 1136 } 1137} 1138 1139func validateBotLocaleSortBy(v *types.BotLocaleSortBy) error { 1140 if v == nil { 1141 return nil 1142 } 1143 invalidParams := smithy.InvalidParamsError{Context: "BotLocaleSortBy"} 1144 if len(v.Attribute) == 0 { 1145 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1146 } 1147 if len(v.Order) == 0 { 1148 invalidParams.Add(smithy.NewErrParamRequired("Order")) 1149 } 1150 if invalidParams.Len() > 0 { 1151 return invalidParams 1152 } else { 1153 return nil 1154 } 1155} 1156 1157func validateBotSortBy(v *types.BotSortBy) error { 1158 if v == nil { 1159 return nil 1160 } 1161 invalidParams := smithy.InvalidParamsError{Context: "BotSortBy"} 1162 if len(v.Attribute) == 0 { 1163 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1164 } 1165 if len(v.Order) == 0 { 1166 invalidParams.Add(smithy.NewErrParamRequired("Order")) 1167 } 1168 if invalidParams.Len() > 0 { 1169 return invalidParams 1170 } else { 1171 return nil 1172 } 1173} 1174 1175func validateBotVersionLocaleDetails(v *types.BotVersionLocaleDetails) error { 1176 if v == nil { 1177 return nil 1178 } 1179 invalidParams := smithy.InvalidParamsError{Context: "BotVersionLocaleDetails"} 1180 if v.SourceBotVersion == nil { 1181 invalidParams.Add(smithy.NewErrParamRequired("SourceBotVersion")) 1182 } 1183 if invalidParams.Len() > 0 { 1184 return invalidParams 1185 } else { 1186 return nil 1187 } 1188} 1189 1190func validateBotVersionLocaleSpecification(v map[string]types.BotVersionLocaleDetails) error { 1191 if v == nil { 1192 return nil 1193 } 1194 invalidParams := smithy.InvalidParamsError{Context: "BotVersionLocaleSpecification"} 1195 for key := range v { 1196 value := v[key] 1197 if err := validateBotVersionLocaleDetails(&value); err != nil { 1198 invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError)) 1199 } 1200 } 1201 if invalidParams.Len() > 0 { 1202 return invalidParams 1203 } else { 1204 return nil 1205 } 1206} 1207 1208func validateBotVersionSortBy(v *types.BotVersionSortBy) error { 1209 if v == nil { 1210 return nil 1211 } 1212 invalidParams := smithy.InvalidParamsError{Context: "BotVersionSortBy"} 1213 if len(v.Attribute) == 0 { 1214 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1215 } 1216 if len(v.Order) == 0 { 1217 invalidParams.Add(smithy.NewErrParamRequired("Order")) 1218 } 1219 if invalidParams.Len() > 0 { 1220 return invalidParams 1221 } else { 1222 return nil 1223 } 1224} 1225 1226func validateBuiltInIntentSortBy(v *types.BuiltInIntentSortBy) error { 1227 if v == nil { 1228 return nil 1229 } 1230 invalidParams := smithy.InvalidParamsError{Context: "BuiltInIntentSortBy"} 1231 if len(v.Attribute) == 0 { 1232 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1233 } 1234 if len(v.Order) == 0 { 1235 invalidParams.Add(smithy.NewErrParamRequired("Order")) 1236 } 1237 if invalidParams.Len() > 0 { 1238 return invalidParams 1239 } else { 1240 return nil 1241 } 1242} 1243 1244func validateBuiltInSlotTypeSortBy(v *types.BuiltInSlotTypeSortBy) error { 1245 if v == nil { 1246 return nil 1247 } 1248 invalidParams := smithy.InvalidParamsError{Context: "BuiltInSlotTypeSortBy"} 1249 if len(v.Attribute) == 0 { 1250 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1251 } 1252 if len(v.Order) == 0 { 1253 invalidParams.Add(smithy.NewErrParamRequired("Order")) 1254 } 1255 if invalidParams.Len() > 0 { 1256 return invalidParams 1257 } else { 1258 return nil 1259 } 1260} 1261 1262func validateButton(v *types.Button) error { 1263 if v == nil { 1264 return nil 1265 } 1266 invalidParams := smithy.InvalidParamsError{Context: "Button"} 1267 if v.Text == nil { 1268 invalidParams.Add(smithy.NewErrParamRequired("Text")) 1269 } 1270 if v.Value == nil { 1271 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1272 } 1273 if invalidParams.Len() > 0 { 1274 return invalidParams 1275 } else { 1276 return nil 1277 } 1278} 1279 1280func validateButtonsList(v []types.Button) error { 1281 if v == nil { 1282 return nil 1283 } 1284 invalidParams := smithy.InvalidParamsError{Context: "ButtonsList"} 1285 for i := range v { 1286 if err := validateButton(&v[i]); err != nil { 1287 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1288 } 1289 } 1290 if invalidParams.Len() > 0 { 1291 return invalidParams 1292 } else { 1293 return nil 1294 } 1295} 1296 1297func validateCloudWatchLogGroupLogDestination(v *types.CloudWatchLogGroupLogDestination) error { 1298 if v == nil { 1299 return nil 1300 } 1301 invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLogGroupLogDestination"} 1302 if v.CloudWatchLogGroupArn == nil { 1303 invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogGroupArn")) 1304 } 1305 if v.LogPrefix == nil { 1306 invalidParams.Add(smithy.NewErrParamRequired("LogPrefix")) 1307 } 1308 if invalidParams.Len() > 0 { 1309 return invalidParams 1310 } else { 1311 return nil 1312 } 1313} 1314 1315func validateCodeHookSpecification(v *types.CodeHookSpecification) error { 1316 if v == nil { 1317 return nil 1318 } 1319 invalidParams := smithy.InvalidParamsError{Context: "CodeHookSpecification"} 1320 if v.LambdaCodeHook == nil { 1321 invalidParams.Add(smithy.NewErrParamRequired("LambdaCodeHook")) 1322 } else if v.LambdaCodeHook != nil { 1323 if err := validateLambdaCodeHook(v.LambdaCodeHook); err != nil { 1324 invalidParams.AddNested("LambdaCodeHook", err.(smithy.InvalidParamsError)) 1325 } 1326 } 1327 if invalidParams.Len() > 0 { 1328 return invalidParams 1329 } else { 1330 return nil 1331 } 1332} 1333 1334func validateConversationLogSettings(v *types.ConversationLogSettings) error { 1335 if v == nil { 1336 return nil 1337 } 1338 invalidParams := smithy.InvalidParamsError{Context: "ConversationLogSettings"} 1339 if v.TextLogSettings != nil { 1340 if err := validateTextLogSettingsList(v.TextLogSettings); err != nil { 1341 invalidParams.AddNested("TextLogSettings", err.(smithy.InvalidParamsError)) 1342 } 1343 } 1344 if v.AudioLogSettings != nil { 1345 if err := validateAudioLogSettingsList(v.AudioLogSettings); err != nil { 1346 invalidParams.AddNested("AudioLogSettings", err.(smithy.InvalidParamsError)) 1347 } 1348 } 1349 if invalidParams.Len() > 0 { 1350 return invalidParams 1351 } else { 1352 return nil 1353 } 1354} 1355 1356func validateCustomPayload(v *types.CustomPayload) error { 1357 if v == nil { 1358 return nil 1359 } 1360 invalidParams := smithy.InvalidParamsError{Context: "CustomPayload"} 1361 if v.Value == nil { 1362 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1363 } 1364 if invalidParams.Len() > 0 { 1365 return invalidParams 1366 } else { 1367 return nil 1368 } 1369} 1370 1371func validateDataPrivacy(v *types.DataPrivacy) error { 1372 if v == nil { 1373 return nil 1374 } 1375 invalidParams := smithy.InvalidParamsError{Context: "DataPrivacy"} 1376 if invalidParams.Len() > 0 { 1377 return invalidParams 1378 } else { 1379 return nil 1380 } 1381} 1382 1383func validateDialogCodeHookSettings(v *types.DialogCodeHookSettings) error { 1384 if v == nil { 1385 return nil 1386 } 1387 invalidParams := smithy.InvalidParamsError{Context: "DialogCodeHookSettings"} 1388 if invalidParams.Len() > 0 { 1389 return invalidParams 1390 } else { 1391 return nil 1392 } 1393} 1394 1395func validateFulfillmentCodeHookSettings(v *types.FulfillmentCodeHookSettings) error { 1396 if v == nil { 1397 return nil 1398 } 1399 invalidParams := smithy.InvalidParamsError{Context: "FulfillmentCodeHookSettings"} 1400 if invalidParams.Len() > 0 { 1401 return invalidParams 1402 } else { 1403 return nil 1404 } 1405} 1406 1407func validateImageResponseCard(v *types.ImageResponseCard) error { 1408 if v == nil { 1409 return nil 1410 } 1411 invalidParams := smithy.InvalidParamsError{Context: "ImageResponseCard"} 1412 if v.Title == nil { 1413 invalidParams.Add(smithy.NewErrParamRequired("Title")) 1414 } 1415 if v.Buttons != nil { 1416 if err := validateButtonsList(v.Buttons); err != nil { 1417 invalidParams.AddNested("Buttons", err.(smithy.InvalidParamsError)) 1418 } 1419 } 1420 if invalidParams.Len() > 0 { 1421 return invalidParams 1422 } else { 1423 return nil 1424 } 1425} 1426 1427func validateInputContext(v *types.InputContext) error { 1428 if v == nil { 1429 return nil 1430 } 1431 invalidParams := smithy.InvalidParamsError{Context: "InputContext"} 1432 if v.Name == nil { 1433 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1434 } 1435 if invalidParams.Len() > 0 { 1436 return invalidParams 1437 } else { 1438 return nil 1439 } 1440} 1441 1442func validateInputContextsList(v []types.InputContext) error { 1443 if v == nil { 1444 return nil 1445 } 1446 invalidParams := smithy.InvalidParamsError{Context: "InputContextsList"} 1447 for i := range v { 1448 if err := validateInputContext(&v[i]); err != nil { 1449 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1450 } 1451 } 1452 if invalidParams.Len() > 0 { 1453 return invalidParams 1454 } else { 1455 return nil 1456 } 1457} 1458 1459func validateIntentClosingSetting(v *types.IntentClosingSetting) error { 1460 if v == nil { 1461 return nil 1462 } 1463 invalidParams := smithy.InvalidParamsError{Context: "IntentClosingSetting"} 1464 if v.ClosingResponse == nil { 1465 invalidParams.Add(smithy.NewErrParamRequired("ClosingResponse")) 1466 } else if v.ClosingResponse != nil { 1467 if err := validateResponseSpecification(v.ClosingResponse); err != nil { 1468 invalidParams.AddNested("ClosingResponse", err.(smithy.InvalidParamsError)) 1469 } 1470 } 1471 if invalidParams.Len() > 0 { 1472 return invalidParams 1473 } else { 1474 return nil 1475 } 1476} 1477 1478func validateIntentConfirmationSetting(v *types.IntentConfirmationSetting) error { 1479 if v == nil { 1480 return nil 1481 } 1482 invalidParams := smithy.InvalidParamsError{Context: "IntentConfirmationSetting"} 1483 if v.PromptSpecification == nil { 1484 invalidParams.Add(smithy.NewErrParamRequired("PromptSpecification")) 1485 } else if v.PromptSpecification != nil { 1486 if err := validatePromptSpecification(v.PromptSpecification); err != nil { 1487 invalidParams.AddNested("PromptSpecification", err.(smithy.InvalidParamsError)) 1488 } 1489 } 1490 if v.DeclinationResponse == nil { 1491 invalidParams.Add(smithy.NewErrParamRequired("DeclinationResponse")) 1492 } else if v.DeclinationResponse != nil { 1493 if err := validateResponseSpecification(v.DeclinationResponse); err != nil { 1494 invalidParams.AddNested("DeclinationResponse", err.(smithy.InvalidParamsError)) 1495 } 1496 } 1497 if invalidParams.Len() > 0 { 1498 return invalidParams 1499 } else { 1500 return nil 1501 } 1502} 1503 1504func validateIntentFilter(v *types.IntentFilter) error { 1505 if v == nil { 1506 return nil 1507 } 1508 invalidParams := smithy.InvalidParamsError{Context: "IntentFilter"} 1509 if len(v.Name) == 0 { 1510 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1511 } 1512 if v.Values == nil { 1513 invalidParams.Add(smithy.NewErrParamRequired("Values")) 1514 } 1515 if len(v.Operator) == 0 { 1516 invalidParams.Add(smithy.NewErrParamRequired("Operator")) 1517 } 1518 if invalidParams.Len() > 0 { 1519 return invalidParams 1520 } else { 1521 return nil 1522 } 1523} 1524 1525func validateIntentFilters(v []types.IntentFilter) error { 1526 if v == nil { 1527 return nil 1528 } 1529 invalidParams := smithy.InvalidParamsError{Context: "IntentFilters"} 1530 for i := range v { 1531 if err := validateIntentFilter(&v[i]); err != nil { 1532 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1533 } 1534 } 1535 if invalidParams.Len() > 0 { 1536 return invalidParams 1537 } else { 1538 return nil 1539 } 1540} 1541 1542func validateIntentSortBy(v *types.IntentSortBy) error { 1543 if v == nil { 1544 return nil 1545 } 1546 invalidParams := smithy.InvalidParamsError{Context: "IntentSortBy"} 1547 if len(v.Attribute) == 0 { 1548 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1549 } 1550 if len(v.Order) == 0 { 1551 invalidParams.Add(smithy.NewErrParamRequired("Order")) 1552 } 1553 if invalidParams.Len() > 0 { 1554 return invalidParams 1555 } else { 1556 return nil 1557 } 1558} 1559 1560func validateKendraConfiguration(v *types.KendraConfiguration) error { 1561 if v == nil { 1562 return nil 1563 } 1564 invalidParams := smithy.InvalidParamsError{Context: "KendraConfiguration"} 1565 if v.KendraIndex == nil { 1566 invalidParams.Add(smithy.NewErrParamRequired("KendraIndex")) 1567 } 1568 if invalidParams.Len() > 0 { 1569 return invalidParams 1570 } else { 1571 return nil 1572 } 1573} 1574 1575func validateLambdaCodeHook(v *types.LambdaCodeHook) error { 1576 if v == nil { 1577 return nil 1578 } 1579 invalidParams := smithy.InvalidParamsError{Context: "LambdaCodeHook"} 1580 if v.LambdaARN == nil { 1581 invalidParams.Add(smithy.NewErrParamRequired("LambdaARN")) 1582 } 1583 if v.CodeHookInterfaceVersion == nil { 1584 invalidParams.Add(smithy.NewErrParamRequired("CodeHookInterfaceVersion")) 1585 } 1586 if invalidParams.Len() > 0 { 1587 return invalidParams 1588 } else { 1589 return nil 1590 } 1591} 1592 1593func validateMessage(v *types.Message) error { 1594 if v == nil { 1595 return nil 1596 } 1597 invalidParams := smithy.InvalidParamsError{Context: "Message"} 1598 if v.PlainTextMessage != nil { 1599 if err := validatePlainTextMessage(v.PlainTextMessage); err != nil { 1600 invalidParams.AddNested("PlainTextMessage", err.(smithy.InvalidParamsError)) 1601 } 1602 } 1603 if v.CustomPayload != nil { 1604 if err := validateCustomPayload(v.CustomPayload); err != nil { 1605 invalidParams.AddNested("CustomPayload", err.(smithy.InvalidParamsError)) 1606 } 1607 } 1608 if v.SsmlMessage != nil { 1609 if err := validateSSMLMessage(v.SsmlMessage); err != nil { 1610 invalidParams.AddNested("SsmlMessage", err.(smithy.InvalidParamsError)) 1611 } 1612 } 1613 if v.ImageResponseCard != nil { 1614 if err := validateImageResponseCard(v.ImageResponseCard); err != nil { 1615 invalidParams.AddNested("ImageResponseCard", err.(smithy.InvalidParamsError)) 1616 } 1617 } 1618 if invalidParams.Len() > 0 { 1619 return invalidParams 1620 } else { 1621 return nil 1622 } 1623} 1624 1625func validateMessageGroup(v *types.MessageGroup) error { 1626 if v == nil { 1627 return nil 1628 } 1629 invalidParams := smithy.InvalidParamsError{Context: "MessageGroup"} 1630 if v.Message == nil { 1631 invalidParams.Add(smithy.NewErrParamRequired("Message")) 1632 } else if v.Message != nil { 1633 if err := validateMessage(v.Message); err != nil { 1634 invalidParams.AddNested("Message", err.(smithy.InvalidParamsError)) 1635 } 1636 } 1637 if v.Variations != nil { 1638 if err := validateMessageVariationsList(v.Variations); err != nil { 1639 invalidParams.AddNested("Variations", err.(smithy.InvalidParamsError)) 1640 } 1641 } 1642 if invalidParams.Len() > 0 { 1643 return invalidParams 1644 } else { 1645 return nil 1646 } 1647} 1648 1649func validateMessageGroupsList(v []types.MessageGroup) error { 1650 if v == nil { 1651 return nil 1652 } 1653 invalidParams := smithy.InvalidParamsError{Context: "MessageGroupsList"} 1654 for i := range v { 1655 if err := validateMessageGroup(&v[i]); err != nil { 1656 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1657 } 1658 } 1659 if invalidParams.Len() > 0 { 1660 return invalidParams 1661 } else { 1662 return nil 1663 } 1664} 1665 1666func validateMessageVariationsList(v []types.Message) error { 1667 if v == nil { 1668 return nil 1669 } 1670 invalidParams := smithy.InvalidParamsError{Context: "MessageVariationsList"} 1671 for i := range v { 1672 if err := validateMessage(&v[i]); err != nil { 1673 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1674 } 1675 } 1676 if invalidParams.Len() > 0 { 1677 return invalidParams 1678 } else { 1679 return nil 1680 } 1681} 1682 1683func validateObfuscationSetting(v *types.ObfuscationSetting) error { 1684 if v == nil { 1685 return nil 1686 } 1687 invalidParams := smithy.InvalidParamsError{Context: "ObfuscationSetting"} 1688 if len(v.ObfuscationSettingType) == 0 { 1689 invalidParams.Add(smithy.NewErrParamRequired("ObfuscationSettingType")) 1690 } 1691 if invalidParams.Len() > 0 { 1692 return invalidParams 1693 } else { 1694 return nil 1695 } 1696} 1697 1698func validateOutputContext(v *types.OutputContext) error { 1699 if v == nil { 1700 return nil 1701 } 1702 invalidParams := smithy.InvalidParamsError{Context: "OutputContext"} 1703 if v.Name == nil { 1704 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1705 } 1706 if v.TimeToLiveInSeconds == nil { 1707 invalidParams.Add(smithy.NewErrParamRequired("TimeToLiveInSeconds")) 1708 } 1709 if v.TurnsToLive == nil { 1710 invalidParams.Add(smithy.NewErrParamRequired("TurnsToLive")) 1711 } 1712 if invalidParams.Len() > 0 { 1713 return invalidParams 1714 } else { 1715 return nil 1716 } 1717} 1718 1719func validateOutputContextsList(v []types.OutputContext) error { 1720 if v == nil { 1721 return nil 1722 } 1723 invalidParams := smithy.InvalidParamsError{Context: "OutputContextsList"} 1724 for i := range v { 1725 if err := validateOutputContext(&v[i]); err != nil { 1726 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1727 } 1728 } 1729 if invalidParams.Len() > 0 { 1730 return invalidParams 1731 } else { 1732 return nil 1733 } 1734} 1735 1736func validatePlainTextMessage(v *types.PlainTextMessage) error { 1737 if v == nil { 1738 return nil 1739 } 1740 invalidParams := smithy.InvalidParamsError{Context: "PlainTextMessage"} 1741 if v.Value == nil { 1742 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1743 } 1744 if invalidParams.Len() > 0 { 1745 return invalidParams 1746 } else { 1747 return nil 1748 } 1749} 1750 1751func validatePromptSpecification(v *types.PromptSpecification) error { 1752 if v == nil { 1753 return nil 1754 } 1755 invalidParams := smithy.InvalidParamsError{Context: "PromptSpecification"} 1756 if v.MessageGroups == nil { 1757 invalidParams.Add(smithy.NewErrParamRequired("MessageGroups")) 1758 } else if v.MessageGroups != nil { 1759 if err := validateMessageGroupsList(v.MessageGroups); err != nil { 1760 invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError)) 1761 } 1762 } 1763 if v.MaxRetries == nil { 1764 invalidParams.Add(smithy.NewErrParamRequired("MaxRetries")) 1765 } 1766 if invalidParams.Len() > 0 { 1767 return invalidParams 1768 } else { 1769 return nil 1770 } 1771} 1772 1773func validateResponseSpecification(v *types.ResponseSpecification) error { 1774 if v == nil { 1775 return nil 1776 } 1777 invalidParams := smithy.InvalidParamsError{Context: "ResponseSpecification"} 1778 if v.MessageGroups == nil { 1779 invalidParams.Add(smithy.NewErrParamRequired("MessageGroups")) 1780 } else if v.MessageGroups != nil { 1781 if err := validateMessageGroupsList(v.MessageGroups); err != nil { 1782 invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError)) 1783 } 1784 } 1785 if invalidParams.Len() > 0 { 1786 return invalidParams 1787 } else { 1788 return nil 1789 } 1790} 1791 1792func validateS3BucketLogDestination(v *types.S3BucketLogDestination) error { 1793 if v == nil { 1794 return nil 1795 } 1796 invalidParams := smithy.InvalidParamsError{Context: "S3BucketLogDestination"} 1797 if v.S3BucketArn == nil { 1798 invalidParams.Add(smithy.NewErrParamRequired("S3BucketArn")) 1799 } 1800 if v.LogPrefix == nil { 1801 invalidParams.Add(smithy.NewErrParamRequired("LogPrefix")) 1802 } 1803 if invalidParams.Len() > 0 { 1804 return invalidParams 1805 } else { 1806 return nil 1807 } 1808} 1809 1810func validateSampleUtterance(v *types.SampleUtterance) error { 1811 if v == nil { 1812 return nil 1813 } 1814 invalidParams := smithy.InvalidParamsError{Context: "SampleUtterance"} 1815 if v.Utterance == nil { 1816 invalidParams.Add(smithy.NewErrParamRequired("Utterance")) 1817 } 1818 if invalidParams.Len() > 0 { 1819 return invalidParams 1820 } else { 1821 return nil 1822 } 1823} 1824 1825func validateSampleUtterancesList(v []types.SampleUtterance) error { 1826 if v == nil { 1827 return nil 1828 } 1829 invalidParams := smithy.InvalidParamsError{Context: "SampleUtterancesList"} 1830 for i := range v { 1831 if err := validateSampleUtterance(&v[i]); err != nil { 1832 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1833 } 1834 } 1835 if invalidParams.Len() > 0 { 1836 return invalidParams 1837 } else { 1838 return nil 1839 } 1840} 1841 1842func validateSampleValue(v *types.SampleValue) error { 1843 if v == nil { 1844 return nil 1845 } 1846 invalidParams := smithy.InvalidParamsError{Context: "SampleValue"} 1847 if v.Value == nil { 1848 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1849 } 1850 if invalidParams.Len() > 0 { 1851 return invalidParams 1852 } else { 1853 return nil 1854 } 1855} 1856 1857func validateSentimentAnalysisSettings(v *types.SentimentAnalysisSettings) error { 1858 if v == nil { 1859 return nil 1860 } 1861 invalidParams := smithy.InvalidParamsError{Context: "SentimentAnalysisSettings"} 1862 if invalidParams.Len() > 0 { 1863 return invalidParams 1864 } else { 1865 return nil 1866 } 1867} 1868 1869func validateSlotDefaultValue(v *types.SlotDefaultValue) error { 1870 if v == nil { 1871 return nil 1872 } 1873 invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValue"} 1874 if v.DefaultValue == nil { 1875 invalidParams.Add(smithy.NewErrParamRequired("DefaultValue")) 1876 } 1877 if invalidParams.Len() > 0 { 1878 return invalidParams 1879 } else { 1880 return nil 1881 } 1882} 1883 1884func validateSlotDefaultValueList(v []types.SlotDefaultValue) error { 1885 if v == nil { 1886 return nil 1887 } 1888 invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValueList"} 1889 for i := range v { 1890 if err := validateSlotDefaultValue(&v[i]); err != nil { 1891 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1892 } 1893 } 1894 if invalidParams.Len() > 0 { 1895 return invalidParams 1896 } else { 1897 return nil 1898 } 1899} 1900 1901func validateSlotDefaultValueSpecification(v *types.SlotDefaultValueSpecification) error { 1902 if v == nil { 1903 return nil 1904 } 1905 invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValueSpecification"} 1906 if v.DefaultValueList == nil { 1907 invalidParams.Add(smithy.NewErrParamRequired("DefaultValueList")) 1908 } else if v.DefaultValueList != nil { 1909 if err := validateSlotDefaultValueList(v.DefaultValueList); err != nil { 1910 invalidParams.AddNested("DefaultValueList", err.(smithy.InvalidParamsError)) 1911 } 1912 } 1913 if invalidParams.Len() > 0 { 1914 return invalidParams 1915 } else { 1916 return nil 1917 } 1918} 1919 1920func validateSlotFilter(v *types.SlotFilter) error { 1921 if v == nil { 1922 return nil 1923 } 1924 invalidParams := smithy.InvalidParamsError{Context: "SlotFilter"} 1925 if len(v.Name) == 0 { 1926 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1927 } 1928 if v.Values == nil { 1929 invalidParams.Add(smithy.NewErrParamRequired("Values")) 1930 } 1931 if len(v.Operator) == 0 { 1932 invalidParams.Add(smithy.NewErrParamRequired("Operator")) 1933 } 1934 if invalidParams.Len() > 0 { 1935 return invalidParams 1936 } else { 1937 return nil 1938 } 1939} 1940 1941func validateSlotFilters(v []types.SlotFilter) error { 1942 if v == nil { 1943 return nil 1944 } 1945 invalidParams := smithy.InvalidParamsError{Context: "SlotFilters"} 1946 for i := range v { 1947 if err := validateSlotFilter(&v[i]); err != nil { 1948 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1949 } 1950 } 1951 if invalidParams.Len() > 0 { 1952 return invalidParams 1953 } else { 1954 return nil 1955 } 1956} 1957 1958func validateSlotPrioritiesList(v []types.SlotPriority) error { 1959 if v == nil { 1960 return nil 1961 } 1962 invalidParams := smithy.InvalidParamsError{Context: "SlotPrioritiesList"} 1963 for i := range v { 1964 if err := validateSlotPriority(&v[i]); err != nil { 1965 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1966 } 1967 } 1968 if invalidParams.Len() > 0 { 1969 return invalidParams 1970 } else { 1971 return nil 1972 } 1973} 1974 1975func validateSlotPriority(v *types.SlotPriority) error { 1976 if v == nil { 1977 return nil 1978 } 1979 invalidParams := smithy.InvalidParamsError{Context: "SlotPriority"} 1980 if v.Priority == nil { 1981 invalidParams.Add(smithy.NewErrParamRequired("Priority")) 1982 } 1983 if v.SlotId == nil { 1984 invalidParams.Add(smithy.NewErrParamRequired("SlotId")) 1985 } 1986 if invalidParams.Len() > 0 { 1987 return invalidParams 1988 } else { 1989 return nil 1990 } 1991} 1992 1993func validateSlotSortBy(v *types.SlotSortBy) error { 1994 if v == nil { 1995 return nil 1996 } 1997 invalidParams := smithy.InvalidParamsError{Context: "SlotSortBy"} 1998 if len(v.Attribute) == 0 { 1999 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 2000 } 2001 if len(v.Order) == 0 { 2002 invalidParams.Add(smithy.NewErrParamRequired("Order")) 2003 } 2004 if invalidParams.Len() > 0 { 2005 return invalidParams 2006 } else { 2007 return nil 2008 } 2009} 2010 2011func validateSlotTypeFilter(v *types.SlotTypeFilter) error { 2012 if v == nil { 2013 return nil 2014 } 2015 invalidParams := smithy.InvalidParamsError{Context: "SlotTypeFilter"} 2016 if len(v.Name) == 0 { 2017 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2018 } 2019 if v.Values == nil { 2020 invalidParams.Add(smithy.NewErrParamRequired("Values")) 2021 } 2022 if len(v.Operator) == 0 { 2023 invalidParams.Add(smithy.NewErrParamRequired("Operator")) 2024 } 2025 if invalidParams.Len() > 0 { 2026 return invalidParams 2027 } else { 2028 return nil 2029 } 2030} 2031 2032func validateSlotTypeFilters(v []types.SlotTypeFilter) error { 2033 if v == nil { 2034 return nil 2035 } 2036 invalidParams := smithy.InvalidParamsError{Context: "SlotTypeFilters"} 2037 for i := range v { 2038 if err := validateSlotTypeFilter(&v[i]); err != nil { 2039 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2040 } 2041 } 2042 if invalidParams.Len() > 0 { 2043 return invalidParams 2044 } else { 2045 return nil 2046 } 2047} 2048 2049func validateSlotTypeSortBy(v *types.SlotTypeSortBy) error { 2050 if v == nil { 2051 return nil 2052 } 2053 invalidParams := smithy.InvalidParamsError{Context: "SlotTypeSortBy"} 2054 if len(v.Attribute) == 0 { 2055 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 2056 } 2057 if len(v.Order) == 0 { 2058 invalidParams.Add(smithy.NewErrParamRequired("Order")) 2059 } 2060 if invalidParams.Len() > 0 { 2061 return invalidParams 2062 } else { 2063 return nil 2064 } 2065} 2066 2067func validateSlotTypeValue(v *types.SlotTypeValue) error { 2068 if v == nil { 2069 return nil 2070 } 2071 invalidParams := smithy.InvalidParamsError{Context: "SlotTypeValue"} 2072 if v.SampleValue != nil { 2073 if err := validateSampleValue(v.SampleValue); err != nil { 2074 invalidParams.AddNested("SampleValue", err.(smithy.InvalidParamsError)) 2075 } 2076 } 2077 if v.Synonyms != nil { 2078 if err := validateSynonymList(v.Synonyms); err != nil { 2079 invalidParams.AddNested("Synonyms", err.(smithy.InvalidParamsError)) 2080 } 2081 } 2082 if invalidParams.Len() > 0 { 2083 return invalidParams 2084 } else { 2085 return nil 2086 } 2087} 2088 2089func validateSlotTypeValues(v []types.SlotTypeValue) error { 2090 if v == nil { 2091 return nil 2092 } 2093 invalidParams := smithy.InvalidParamsError{Context: "SlotTypeValues"} 2094 for i := range v { 2095 if err := validateSlotTypeValue(&v[i]); err != nil { 2096 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2097 } 2098 } 2099 if invalidParams.Len() > 0 { 2100 return invalidParams 2101 } else { 2102 return nil 2103 } 2104} 2105 2106func validateSlotValueElicitationSetting(v *types.SlotValueElicitationSetting) error { 2107 if v == nil { 2108 return nil 2109 } 2110 invalidParams := smithy.InvalidParamsError{Context: "SlotValueElicitationSetting"} 2111 if v.DefaultValueSpecification != nil { 2112 if err := validateSlotDefaultValueSpecification(v.DefaultValueSpecification); err != nil { 2113 invalidParams.AddNested("DefaultValueSpecification", err.(smithy.InvalidParamsError)) 2114 } 2115 } 2116 if len(v.SlotConstraint) == 0 { 2117 invalidParams.Add(smithy.NewErrParamRequired("SlotConstraint")) 2118 } 2119 if v.PromptSpecification != nil { 2120 if err := validatePromptSpecification(v.PromptSpecification); err != nil { 2121 invalidParams.AddNested("PromptSpecification", err.(smithy.InvalidParamsError)) 2122 } 2123 } 2124 if v.SampleUtterances != nil { 2125 if err := validateSampleUtterancesList(v.SampleUtterances); err != nil { 2126 invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError)) 2127 } 2128 } 2129 if v.WaitAndContinueSpecification != nil { 2130 if err := validateWaitAndContinueSpecification(v.WaitAndContinueSpecification); err != nil { 2131 invalidParams.AddNested("WaitAndContinueSpecification", err.(smithy.InvalidParamsError)) 2132 } 2133 } 2134 if invalidParams.Len() > 0 { 2135 return invalidParams 2136 } else { 2137 return nil 2138 } 2139} 2140 2141func validateSlotValueRegexFilter(v *types.SlotValueRegexFilter) error { 2142 if v == nil { 2143 return nil 2144 } 2145 invalidParams := smithy.InvalidParamsError{Context: "SlotValueRegexFilter"} 2146 if v.Pattern == nil { 2147 invalidParams.Add(smithy.NewErrParamRequired("Pattern")) 2148 } 2149 if invalidParams.Len() > 0 { 2150 return invalidParams 2151 } else { 2152 return nil 2153 } 2154} 2155 2156func validateSlotValueSelectionSetting(v *types.SlotValueSelectionSetting) error { 2157 if v == nil { 2158 return nil 2159 } 2160 invalidParams := smithy.InvalidParamsError{Context: "SlotValueSelectionSetting"} 2161 if len(v.ResolutionStrategy) == 0 { 2162 invalidParams.Add(smithy.NewErrParamRequired("ResolutionStrategy")) 2163 } 2164 if v.RegexFilter != nil { 2165 if err := validateSlotValueRegexFilter(v.RegexFilter); err != nil { 2166 invalidParams.AddNested("RegexFilter", err.(smithy.InvalidParamsError)) 2167 } 2168 } 2169 if invalidParams.Len() > 0 { 2170 return invalidParams 2171 } else { 2172 return nil 2173 } 2174} 2175 2176func validateSSMLMessage(v *types.SSMLMessage) error { 2177 if v == nil { 2178 return nil 2179 } 2180 invalidParams := smithy.InvalidParamsError{Context: "SSMLMessage"} 2181 if v.Value == nil { 2182 invalidParams.Add(smithy.NewErrParamRequired("Value")) 2183 } 2184 if invalidParams.Len() > 0 { 2185 return invalidParams 2186 } else { 2187 return nil 2188 } 2189} 2190 2191func validateStillWaitingResponseSpecification(v *types.StillWaitingResponseSpecification) error { 2192 if v == nil { 2193 return nil 2194 } 2195 invalidParams := smithy.InvalidParamsError{Context: "StillWaitingResponseSpecification"} 2196 if v.MessageGroups == nil { 2197 invalidParams.Add(smithy.NewErrParamRequired("MessageGroups")) 2198 } else if v.MessageGroups != nil { 2199 if err := validateMessageGroupsList(v.MessageGroups); err != nil { 2200 invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError)) 2201 } 2202 } 2203 if v.FrequencyInSeconds == nil { 2204 invalidParams.Add(smithy.NewErrParamRequired("FrequencyInSeconds")) 2205 } 2206 if v.TimeoutInSeconds == nil { 2207 invalidParams.Add(smithy.NewErrParamRequired("TimeoutInSeconds")) 2208 } 2209 if invalidParams.Len() > 0 { 2210 return invalidParams 2211 } else { 2212 return nil 2213 } 2214} 2215 2216func validateSynonymList(v []types.SampleValue) error { 2217 if v == nil { 2218 return nil 2219 } 2220 invalidParams := smithy.InvalidParamsError{Context: "SynonymList"} 2221 for i := range v { 2222 if err := validateSampleValue(&v[i]); err != nil { 2223 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2224 } 2225 } 2226 if invalidParams.Len() > 0 { 2227 return invalidParams 2228 } else { 2229 return nil 2230 } 2231} 2232 2233func validateTextLogDestination(v *types.TextLogDestination) error { 2234 if v == nil { 2235 return nil 2236 } 2237 invalidParams := smithy.InvalidParamsError{Context: "TextLogDestination"} 2238 if v.CloudWatch == nil { 2239 invalidParams.Add(smithy.NewErrParamRequired("CloudWatch")) 2240 } else if v.CloudWatch != nil { 2241 if err := validateCloudWatchLogGroupLogDestination(v.CloudWatch); err != nil { 2242 invalidParams.AddNested("CloudWatch", err.(smithy.InvalidParamsError)) 2243 } 2244 } 2245 if invalidParams.Len() > 0 { 2246 return invalidParams 2247 } else { 2248 return nil 2249 } 2250} 2251 2252func validateTextLogSetting(v *types.TextLogSetting) error { 2253 if v == nil { 2254 return nil 2255 } 2256 invalidParams := smithy.InvalidParamsError{Context: "TextLogSetting"} 2257 if v.Destination == nil { 2258 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2259 } else if v.Destination != nil { 2260 if err := validateTextLogDestination(v.Destination); err != nil { 2261 invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError)) 2262 } 2263 } 2264 if invalidParams.Len() > 0 { 2265 return invalidParams 2266 } else { 2267 return nil 2268 } 2269} 2270 2271func validateTextLogSettingsList(v []types.TextLogSetting) error { 2272 if v == nil { 2273 return nil 2274 } 2275 invalidParams := smithy.InvalidParamsError{Context: "TextLogSettingsList"} 2276 for i := range v { 2277 if err := validateTextLogSetting(&v[i]); err != nil { 2278 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2279 } 2280 } 2281 if invalidParams.Len() > 0 { 2282 return invalidParams 2283 } else { 2284 return nil 2285 } 2286} 2287 2288func validateVoiceSettings(v *types.VoiceSettings) error { 2289 if v == nil { 2290 return nil 2291 } 2292 invalidParams := smithy.InvalidParamsError{Context: "VoiceSettings"} 2293 if v.VoiceId == nil { 2294 invalidParams.Add(smithy.NewErrParamRequired("VoiceId")) 2295 } 2296 if invalidParams.Len() > 0 { 2297 return invalidParams 2298 } else { 2299 return nil 2300 } 2301} 2302 2303func validateWaitAndContinueSpecification(v *types.WaitAndContinueSpecification) error { 2304 if v == nil { 2305 return nil 2306 } 2307 invalidParams := smithy.InvalidParamsError{Context: "WaitAndContinueSpecification"} 2308 if v.WaitingResponse == nil { 2309 invalidParams.Add(smithy.NewErrParamRequired("WaitingResponse")) 2310 } else if v.WaitingResponse != nil { 2311 if err := validateResponseSpecification(v.WaitingResponse); err != nil { 2312 invalidParams.AddNested("WaitingResponse", err.(smithy.InvalidParamsError)) 2313 } 2314 } 2315 if v.ContinueResponse == nil { 2316 invalidParams.Add(smithy.NewErrParamRequired("ContinueResponse")) 2317 } else if v.ContinueResponse != nil { 2318 if err := validateResponseSpecification(v.ContinueResponse); err != nil { 2319 invalidParams.AddNested("ContinueResponse", err.(smithy.InvalidParamsError)) 2320 } 2321 } 2322 if v.StillWaitingResponse != nil { 2323 if err := validateStillWaitingResponseSpecification(v.StillWaitingResponse); err != nil { 2324 invalidParams.AddNested("StillWaitingResponse", err.(smithy.InvalidParamsError)) 2325 } 2326 } 2327 if invalidParams.Len() > 0 { 2328 return invalidParams 2329 } else { 2330 return nil 2331 } 2332} 2333 2334func validateOpBuildBotLocaleInput(v *BuildBotLocaleInput) error { 2335 if v == nil { 2336 return nil 2337 } 2338 invalidParams := smithy.InvalidParamsError{Context: "BuildBotLocaleInput"} 2339 if v.BotId == nil { 2340 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2341 } 2342 if v.BotVersion == nil { 2343 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2344 } 2345 if v.LocaleId == nil { 2346 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2347 } 2348 if invalidParams.Len() > 0 { 2349 return invalidParams 2350 } else { 2351 return nil 2352 } 2353} 2354 2355func validateOpCreateBotAliasInput(v *CreateBotAliasInput) error { 2356 if v == nil { 2357 return nil 2358 } 2359 invalidParams := smithy.InvalidParamsError{Context: "CreateBotAliasInput"} 2360 if v.BotAliasName == nil { 2361 invalidParams.Add(smithy.NewErrParamRequired("BotAliasName")) 2362 } 2363 if v.BotAliasLocaleSettings != nil { 2364 if err := validateBotAliasLocaleSettingsMap(v.BotAliasLocaleSettings); err != nil { 2365 invalidParams.AddNested("BotAliasLocaleSettings", err.(smithy.InvalidParamsError)) 2366 } 2367 } 2368 if v.ConversationLogSettings != nil { 2369 if err := validateConversationLogSettings(v.ConversationLogSettings); err != nil { 2370 invalidParams.AddNested("ConversationLogSettings", err.(smithy.InvalidParamsError)) 2371 } 2372 } 2373 if v.SentimentAnalysisSettings != nil { 2374 if err := validateSentimentAnalysisSettings(v.SentimentAnalysisSettings); err != nil { 2375 invalidParams.AddNested("SentimentAnalysisSettings", err.(smithy.InvalidParamsError)) 2376 } 2377 } 2378 if v.BotId == nil { 2379 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2380 } 2381 if invalidParams.Len() > 0 { 2382 return invalidParams 2383 } else { 2384 return nil 2385 } 2386} 2387 2388func validateOpCreateBotInput(v *CreateBotInput) error { 2389 if v == nil { 2390 return nil 2391 } 2392 invalidParams := smithy.InvalidParamsError{Context: "CreateBotInput"} 2393 if v.BotName == nil { 2394 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 2395 } 2396 if v.RoleArn == nil { 2397 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 2398 } 2399 if v.DataPrivacy == nil { 2400 invalidParams.Add(smithy.NewErrParamRequired("DataPrivacy")) 2401 } else if v.DataPrivacy != nil { 2402 if err := validateDataPrivacy(v.DataPrivacy); err != nil { 2403 invalidParams.AddNested("DataPrivacy", err.(smithy.InvalidParamsError)) 2404 } 2405 } 2406 if v.IdleSessionTTLInSeconds == nil { 2407 invalidParams.Add(smithy.NewErrParamRequired("IdleSessionTTLInSeconds")) 2408 } 2409 if invalidParams.Len() > 0 { 2410 return invalidParams 2411 } else { 2412 return nil 2413 } 2414} 2415 2416func validateOpCreateBotLocaleInput(v *CreateBotLocaleInput) error { 2417 if v == nil { 2418 return nil 2419 } 2420 invalidParams := smithy.InvalidParamsError{Context: "CreateBotLocaleInput"} 2421 if v.BotId == nil { 2422 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2423 } 2424 if v.BotVersion == nil { 2425 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2426 } 2427 if v.LocaleId == nil { 2428 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2429 } 2430 if v.NluIntentConfidenceThreshold == nil { 2431 invalidParams.Add(smithy.NewErrParamRequired("NluIntentConfidenceThreshold")) 2432 } 2433 if v.VoiceSettings != nil { 2434 if err := validateVoiceSettings(v.VoiceSettings); err != nil { 2435 invalidParams.AddNested("VoiceSettings", err.(smithy.InvalidParamsError)) 2436 } 2437 } 2438 if invalidParams.Len() > 0 { 2439 return invalidParams 2440 } else { 2441 return nil 2442 } 2443} 2444 2445func validateOpCreateBotVersionInput(v *CreateBotVersionInput) error { 2446 if v == nil { 2447 return nil 2448 } 2449 invalidParams := smithy.InvalidParamsError{Context: "CreateBotVersionInput"} 2450 if v.BotId == nil { 2451 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2452 } 2453 if v.BotVersionLocaleSpecification == nil { 2454 invalidParams.Add(smithy.NewErrParamRequired("BotVersionLocaleSpecification")) 2455 } else if v.BotVersionLocaleSpecification != nil { 2456 if err := validateBotVersionLocaleSpecification(v.BotVersionLocaleSpecification); err != nil { 2457 invalidParams.AddNested("BotVersionLocaleSpecification", err.(smithy.InvalidParamsError)) 2458 } 2459 } 2460 if invalidParams.Len() > 0 { 2461 return invalidParams 2462 } else { 2463 return nil 2464 } 2465} 2466 2467func validateOpCreateIntentInput(v *CreateIntentInput) error { 2468 if v == nil { 2469 return nil 2470 } 2471 invalidParams := smithy.InvalidParamsError{Context: "CreateIntentInput"} 2472 if v.IntentName == nil { 2473 invalidParams.Add(smithy.NewErrParamRequired("IntentName")) 2474 } 2475 if v.SampleUtterances != nil { 2476 if err := validateSampleUtterancesList(v.SampleUtterances); err != nil { 2477 invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError)) 2478 } 2479 } 2480 if v.DialogCodeHook != nil { 2481 if err := validateDialogCodeHookSettings(v.DialogCodeHook); err != nil { 2482 invalidParams.AddNested("DialogCodeHook", err.(smithy.InvalidParamsError)) 2483 } 2484 } 2485 if v.FulfillmentCodeHook != nil { 2486 if err := validateFulfillmentCodeHookSettings(v.FulfillmentCodeHook); err != nil { 2487 invalidParams.AddNested("FulfillmentCodeHook", err.(smithy.InvalidParamsError)) 2488 } 2489 } 2490 if v.IntentConfirmationSetting != nil { 2491 if err := validateIntentConfirmationSetting(v.IntentConfirmationSetting); err != nil { 2492 invalidParams.AddNested("IntentConfirmationSetting", err.(smithy.InvalidParamsError)) 2493 } 2494 } 2495 if v.IntentClosingSetting != nil { 2496 if err := validateIntentClosingSetting(v.IntentClosingSetting); err != nil { 2497 invalidParams.AddNested("IntentClosingSetting", err.(smithy.InvalidParamsError)) 2498 } 2499 } 2500 if v.InputContexts != nil { 2501 if err := validateInputContextsList(v.InputContexts); err != nil { 2502 invalidParams.AddNested("InputContexts", err.(smithy.InvalidParamsError)) 2503 } 2504 } 2505 if v.OutputContexts != nil { 2506 if err := validateOutputContextsList(v.OutputContexts); err != nil { 2507 invalidParams.AddNested("OutputContexts", err.(smithy.InvalidParamsError)) 2508 } 2509 } 2510 if v.KendraConfiguration != nil { 2511 if err := validateKendraConfiguration(v.KendraConfiguration); err != nil { 2512 invalidParams.AddNested("KendraConfiguration", err.(smithy.InvalidParamsError)) 2513 } 2514 } 2515 if v.BotId == nil { 2516 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2517 } 2518 if v.BotVersion == nil { 2519 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2520 } 2521 if v.LocaleId == nil { 2522 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2523 } 2524 if invalidParams.Len() > 0 { 2525 return invalidParams 2526 } else { 2527 return nil 2528 } 2529} 2530 2531func validateOpCreateSlotInput(v *CreateSlotInput) error { 2532 if v == nil { 2533 return nil 2534 } 2535 invalidParams := smithy.InvalidParamsError{Context: "CreateSlotInput"} 2536 if v.SlotName == nil { 2537 invalidParams.Add(smithy.NewErrParamRequired("SlotName")) 2538 } 2539 if v.SlotTypeId == nil { 2540 invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId")) 2541 } 2542 if v.ValueElicitationSetting == nil { 2543 invalidParams.Add(smithy.NewErrParamRequired("ValueElicitationSetting")) 2544 } else if v.ValueElicitationSetting != nil { 2545 if err := validateSlotValueElicitationSetting(v.ValueElicitationSetting); err != nil { 2546 invalidParams.AddNested("ValueElicitationSetting", err.(smithy.InvalidParamsError)) 2547 } 2548 } 2549 if v.ObfuscationSetting != nil { 2550 if err := validateObfuscationSetting(v.ObfuscationSetting); err != nil { 2551 invalidParams.AddNested("ObfuscationSetting", err.(smithy.InvalidParamsError)) 2552 } 2553 } 2554 if v.BotId == nil { 2555 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2556 } 2557 if v.BotVersion == nil { 2558 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2559 } 2560 if v.LocaleId == nil { 2561 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2562 } 2563 if v.IntentId == nil { 2564 invalidParams.Add(smithy.NewErrParamRequired("IntentId")) 2565 } 2566 if invalidParams.Len() > 0 { 2567 return invalidParams 2568 } else { 2569 return nil 2570 } 2571} 2572 2573func validateOpCreateSlotTypeInput(v *CreateSlotTypeInput) error { 2574 if v == nil { 2575 return nil 2576 } 2577 invalidParams := smithy.InvalidParamsError{Context: "CreateSlotTypeInput"} 2578 if v.SlotTypeName == nil { 2579 invalidParams.Add(smithy.NewErrParamRequired("SlotTypeName")) 2580 } 2581 if v.SlotTypeValues != nil { 2582 if err := validateSlotTypeValues(v.SlotTypeValues); err != nil { 2583 invalidParams.AddNested("SlotTypeValues", err.(smithy.InvalidParamsError)) 2584 } 2585 } 2586 if v.ValueSelectionSetting == nil { 2587 invalidParams.Add(smithy.NewErrParamRequired("ValueSelectionSetting")) 2588 } else if v.ValueSelectionSetting != nil { 2589 if err := validateSlotValueSelectionSetting(v.ValueSelectionSetting); err != nil { 2590 invalidParams.AddNested("ValueSelectionSetting", err.(smithy.InvalidParamsError)) 2591 } 2592 } 2593 if v.BotId == nil { 2594 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2595 } 2596 if v.BotVersion == nil { 2597 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2598 } 2599 if v.LocaleId == nil { 2600 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2601 } 2602 if invalidParams.Len() > 0 { 2603 return invalidParams 2604 } else { 2605 return nil 2606 } 2607} 2608 2609func validateOpDeleteBotAliasInput(v *DeleteBotAliasInput) error { 2610 if v == nil { 2611 return nil 2612 } 2613 invalidParams := smithy.InvalidParamsError{Context: "DeleteBotAliasInput"} 2614 if v.BotAliasId == nil { 2615 invalidParams.Add(smithy.NewErrParamRequired("BotAliasId")) 2616 } 2617 if v.BotId == nil { 2618 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2619 } 2620 if invalidParams.Len() > 0 { 2621 return invalidParams 2622 } else { 2623 return nil 2624 } 2625} 2626 2627func validateOpDeleteBotInput(v *DeleteBotInput) error { 2628 if v == nil { 2629 return nil 2630 } 2631 invalidParams := smithy.InvalidParamsError{Context: "DeleteBotInput"} 2632 if v.BotId == nil { 2633 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2634 } 2635 if invalidParams.Len() > 0 { 2636 return invalidParams 2637 } else { 2638 return nil 2639 } 2640} 2641 2642func validateOpDeleteBotLocaleInput(v *DeleteBotLocaleInput) error { 2643 if v == nil { 2644 return nil 2645 } 2646 invalidParams := smithy.InvalidParamsError{Context: "DeleteBotLocaleInput"} 2647 if v.BotId == nil { 2648 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2649 } 2650 if v.BotVersion == nil { 2651 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2652 } 2653 if v.LocaleId == nil { 2654 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2655 } 2656 if invalidParams.Len() > 0 { 2657 return invalidParams 2658 } else { 2659 return nil 2660 } 2661} 2662 2663func validateOpDeleteBotVersionInput(v *DeleteBotVersionInput) error { 2664 if v == nil { 2665 return nil 2666 } 2667 invalidParams := smithy.InvalidParamsError{Context: "DeleteBotVersionInput"} 2668 if v.BotId == nil { 2669 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2670 } 2671 if v.BotVersion == nil { 2672 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2673 } 2674 if invalidParams.Len() > 0 { 2675 return invalidParams 2676 } else { 2677 return nil 2678 } 2679} 2680 2681func validateOpDeleteIntentInput(v *DeleteIntentInput) error { 2682 if v == nil { 2683 return nil 2684 } 2685 invalidParams := smithy.InvalidParamsError{Context: "DeleteIntentInput"} 2686 if v.IntentId == nil { 2687 invalidParams.Add(smithy.NewErrParamRequired("IntentId")) 2688 } 2689 if v.BotId == nil { 2690 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2691 } 2692 if v.BotVersion == nil { 2693 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2694 } 2695 if v.LocaleId == nil { 2696 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2697 } 2698 if invalidParams.Len() > 0 { 2699 return invalidParams 2700 } else { 2701 return nil 2702 } 2703} 2704 2705func validateOpDeleteSlotInput(v *DeleteSlotInput) error { 2706 if v == nil { 2707 return nil 2708 } 2709 invalidParams := smithy.InvalidParamsError{Context: "DeleteSlotInput"} 2710 if v.SlotId == nil { 2711 invalidParams.Add(smithy.NewErrParamRequired("SlotId")) 2712 } 2713 if v.BotId == nil { 2714 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2715 } 2716 if v.BotVersion == nil { 2717 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2718 } 2719 if v.LocaleId == nil { 2720 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2721 } 2722 if v.IntentId == nil { 2723 invalidParams.Add(smithy.NewErrParamRequired("IntentId")) 2724 } 2725 if invalidParams.Len() > 0 { 2726 return invalidParams 2727 } else { 2728 return nil 2729 } 2730} 2731 2732func validateOpDeleteSlotTypeInput(v *DeleteSlotTypeInput) error { 2733 if v == nil { 2734 return nil 2735 } 2736 invalidParams := smithy.InvalidParamsError{Context: "DeleteSlotTypeInput"} 2737 if v.SlotTypeId == nil { 2738 invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId")) 2739 } 2740 if v.BotId == nil { 2741 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2742 } 2743 if v.BotVersion == nil { 2744 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2745 } 2746 if v.LocaleId == nil { 2747 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2748 } 2749 if invalidParams.Len() > 0 { 2750 return invalidParams 2751 } else { 2752 return nil 2753 } 2754} 2755 2756func validateOpDescribeBotAliasInput(v *DescribeBotAliasInput) error { 2757 if v == nil { 2758 return nil 2759 } 2760 invalidParams := smithy.InvalidParamsError{Context: "DescribeBotAliasInput"} 2761 if v.BotAliasId == nil { 2762 invalidParams.Add(smithy.NewErrParamRequired("BotAliasId")) 2763 } 2764 if v.BotId == nil { 2765 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2766 } 2767 if invalidParams.Len() > 0 { 2768 return invalidParams 2769 } else { 2770 return nil 2771 } 2772} 2773 2774func validateOpDescribeBotInput(v *DescribeBotInput) error { 2775 if v == nil { 2776 return nil 2777 } 2778 invalidParams := smithy.InvalidParamsError{Context: "DescribeBotInput"} 2779 if v.BotId == nil { 2780 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2781 } 2782 if invalidParams.Len() > 0 { 2783 return invalidParams 2784 } else { 2785 return nil 2786 } 2787} 2788 2789func validateOpDescribeBotLocaleInput(v *DescribeBotLocaleInput) error { 2790 if v == nil { 2791 return nil 2792 } 2793 invalidParams := smithy.InvalidParamsError{Context: "DescribeBotLocaleInput"} 2794 if v.BotId == nil { 2795 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2796 } 2797 if v.BotVersion == nil { 2798 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2799 } 2800 if v.LocaleId == nil { 2801 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2802 } 2803 if invalidParams.Len() > 0 { 2804 return invalidParams 2805 } else { 2806 return nil 2807 } 2808} 2809 2810func validateOpDescribeBotVersionInput(v *DescribeBotVersionInput) error { 2811 if v == nil { 2812 return nil 2813 } 2814 invalidParams := smithy.InvalidParamsError{Context: "DescribeBotVersionInput"} 2815 if v.BotId == nil { 2816 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2817 } 2818 if v.BotVersion == nil { 2819 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2820 } 2821 if invalidParams.Len() > 0 { 2822 return invalidParams 2823 } else { 2824 return nil 2825 } 2826} 2827 2828func validateOpDescribeIntentInput(v *DescribeIntentInput) error { 2829 if v == nil { 2830 return nil 2831 } 2832 invalidParams := smithy.InvalidParamsError{Context: "DescribeIntentInput"} 2833 if v.IntentId == nil { 2834 invalidParams.Add(smithy.NewErrParamRequired("IntentId")) 2835 } 2836 if v.BotId == nil { 2837 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2838 } 2839 if v.BotVersion == nil { 2840 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2841 } 2842 if v.LocaleId == nil { 2843 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2844 } 2845 if invalidParams.Len() > 0 { 2846 return invalidParams 2847 } else { 2848 return nil 2849 } 2850} 2851 2852func validateOpDescribeSlotInput(v *DescribeSlotInput) error { 2853 if v == nil { 2854 return nil 2855 } 2856 invalidParams := smithy.InvalidParamsError{Context: "DescribeSlotInput"} 2857 if v.SlotId == nil { 2858 invalidParams.Add(smithy.NewErrParamRequired("SlotId")) 2859 } 2860 if v.BotId == nil { 2861 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2862 } 2863 if v.BotVersion == nil { 2864 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2865 } 2866 if v.LocaleId == nil { 2867 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2868 } 2869 if v.IntentId == nil { 2870 invalidParams.Add(smithy.NewErrParamRequired("IntentId")) 2871 } 2872 if invalidParams.Len() > 0 { 2873 return invalidParams 2874 } else { 2875 return nil 2876 } 2877} 2878 2879func validateOpDescribeSlotTypeInput(v *DescribeSlotTypeInput) error { 2880 if v == nil { 2881 return nil 2882 } 2883 invalidParams := smithy.InvalidParamsError{Context: "DescribeSlotTypeInput"} 2884 if v.SlotTypeId == nil { 2885 invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId")) 2886 } 2887 if v.BotId == nil { 2888 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2889 } 2890 if v.BotVersion == nil { 2891 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2892 } 2893 if v.LocaleId == nil { 2894 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2895 } 2896 if invalidParams.Len() > 0 { 2897 return invalidParams 2898 } else { 2899 return nil 2900 } 2901} 2902 2903func validateOpListBotAliasesInput(v *ListBotAliasesInput) error { 2904 if v == nil { 2905 return nil 2906 } 2907 invalidParams := smithy.InvalidParamsError{Context: "ListBotAliasesInput"} 2908 if v.BotId == nil { 2909 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2910 } 2911 if invalidParams.Len() > 0 { 2912 return invalidParams 2913 } else { 2914 return nil 2915 } 2916} 2917 2918func validateOpListBotLocalesInput(v *ListBotLocalesInput) error { 2919 if v == nil { 2920 return nil 2921 } 2922 invalidParams := smithy.InvalidParamsError{Context: "ListBotLocalesInput"} 2923 if v.BotId == nil { 2924 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2925 } 2926 if v.BotVersion == nil { 2927 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 2928 } 2929 if v.SortBy != nil { 2930 if err := validateBotLocaleSortBy(v.SortBy); err != nil { 2931 invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError)) 2932 } 2933 } 2934 if v.Filters != nil { 2935 if err := validateBotLocaleFilters(v.Filters); err != nil { 2936 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 2937 } 2938 } 2939 if invalidParams.Len() > 0 { 2940 return invalidParams 2941 } else { 2942 return nil 2943 } 2944} 2945 2946func validateOpListBotsInput(v *ListBotsInput) error { 2947 if v == nil { 2948 return nil 2949 } 2950 invalidParams := smithy.InvalidParamsError{Context: "ListBotsInput"} 2951 if v.SortBy != nil { 2952 if err := validateBotSortBy(v.SortBy); err != nil { 2953 invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError)) 2954 } 2955 } 2956 if v.Filters != nil { 2957 if err := validateBotFilters(v.Filters); err != nil { 2958 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 2959 } 2960 } 2961 if invalidParams.Len() > 0 { 2962 return invalidParams 2963 } else { 2964 return nil 2965 } 2966} 2967 2968func validateOpListBotVersionsInput(v *ListBotVersionsInput) error { 2969 if v == nil { 2970 return nil 2971 } 2972 invalidParams := smithy.InvalidParamsError{Context: "ListBotVersionsInput"} 2973 if v.BotId == nil { 2974 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 2975 } 2976 if v.SortBy != nil { 2977 if err := validateBotVersionSortBy(v.SortBy); err != nil { 2978 invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError)) 2979 } 2980 } 2981 if invalidParams.Len() > 0 { 2982 return invalidParams 2983 } else { 2984 return nil 2985 } 2986} 2987 2988func validateOpListBuiltInIntentsInput(v *ListBuiltInIntentsInput) error { 2989 if v == nil { 2990 return nil 2991 } 2992 invalidParams := smithy.InvalidParamsError{Context: "ListBuiltInIntentsInput"} 2993 if v.LocaleId == nil { 2994 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 2995 } 2996 if v.SortBy != nil { 2997 if err := validateBuiltInIntentSortBy(v.SortBy); err != nil { 2998 invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError)) 2999 } 3000 } 3001 if invalidParams.Len() > 0 { 3002 return invalidParams 3003 } else { 3004 return nil 3005 } 3006} 3007 3008func validateOpListBuiltInSlotTypesInput(v *ListBuiltInSlotTypesInput) error { 3009 if v == nil { 3010 return nil 3011 } 3012 invalidParams := smithy.InvalidParamsError{Context: "ListBuiltInSlotTypesInput"} 3013 if v.LocaleId == nil { 3014 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 3015 } 3016 if v.SortBy != nil { 3017 if err := validateBuiltInSlotTypeSortBy(v.SortBy); err != nil { 3018 invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError)) 3019 } 3020 } 3021 if invalidParams.Len() > 0 { 3022 return invalidParams 3023 } else { 3024 return nil 3025 } 3026} 3027 3028func validateOpListIntentsInput(v *ListIntentsInput) error { 3029 if v == nil { 3030 return nil 3031 } 3032 invalidParams := smithy.InvalidParamsError{Context: "ListIntentsInput"} 3033 if v.BotId == nil { 3034 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3035 } 3036 if v.BotVersion == nil { 3037 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 3038 } 3039 if v.LocaleId == nil { 3040 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 3041 } 3042 if v.SortBy != nil { 3043 if err := validateIntentSortBy(v.SortBy); err != nil { 3044 invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError)) 3045 } 3046 } 3047 if v.Filters != nil { 3048 if err := validateIntentFilters(v.Filters); err != nil { 3049 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 3050 } 3051 } 3052 if invalidParams.Len() > 0 { 3053 return invalidParams 3054 } else { 3055 return nil 3056 } 3057} 3058 3059func validateOpListSlotsInput(v *ListSlotsInput) error { 3060 if v == nil { 3061 return nil 3062 } 3063 invalidParams := smithy.InvalidParamsError{Context: "ListSlotsInput"} 3064 if v.BotId == nil { 3065 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3066 } 3067 if v.BotVersion == nil { 3068 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 3069 } 3070 if v.LocaleId == nil { 3071 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 3072 } 3073 if v.IntentId == nil { 3074 invalidParams.Add(smithy.NewErrParamRequired("IntentId")) 3075 } 3076 if v.SortBy != nil { 3077 if err := validateSlotSortBy(v.SortBy); err != nil { 3078 invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError)) 3079 } 3080 } 3081 if v.Filters != nil { 3082 if err := validateSlotFilters(v.Filters); err != nil { 3083 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 3084 } 3085 } 3086 if invalidParams.Len() > 0 { 3087 return invalidParams 3088 } else { 3089 return nil 3090 } 3091} 3092 3093func validateOpListSlotTypesInput(v *ListSlotTypesInput) error { 3094 if v == nil { 3095 return nil 3096 } 3097 invalidParams := smithy.InvalidParamsError{Context: "ListSlotTypesInput"} 3098 if v.BotId == nil { 3099 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3100 } 3101 if v.BotVersion == nil { 3102 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 3103 } 3104 if v.LocaleId == nil { 3105 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 3106 } 3107 if v.SortBy != nil { 3108 if err := validateSlotTypeSortBy(v.SortBy); err != nil { 3109 invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError)) 3110 } 3111 } 3112 if v.Filters != nil { 3113 if err := validateSlotTypeFilters(v.Filters); err != nil { 3114 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 3115 } 3116 } 3117 if invalidParams.Len() > 0 { 3118 return invalidParams 3119 } else { 3120 return nil 3121 } 3122} 3123 3124func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 3125 if v == nil { 3126 return nil 3127 } 3128 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 3129 if v.ResourceARN == nil { 3130 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 3131 } 3132 if invalidParams.Len() > 0 { 3133 return invalidParams 3134 } else { 3135 return nil 3136 } 3137} 3138 3139func validateOpTagResourceInput(v *TagResourceInput) error { 3140 if v == nil { 3141 return nil 3142 } 3143 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 3144 if v.ResourceARN == nil { 3145 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 3146 } 3147 if v.Tags == nil { 3148 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 3149 } 3150 if invalidParams.Len() > 0 { 3151 return invalidParams 3152 } else { 3153 return nil 3154 } 3155} 3156 3157func validateOpUntagResourceInput(v *UntagResourceInput) error { 3158 if v == nil { 3159 return nil 3160 } 3161 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 3162 if v.ResourceARN == nil { 3163 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 3164 } 3165 if v.TagKeys == nil { 3166 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 3167 } 3168 if invalidParams.Len() > 0 { 3169 return invalidParams 3170 } else { 3171 return nil 3172 } 3173} 3174 3175func validateOpUpdateBotAliasInput(v *UpdateBotAliasInput) error { 3176 if v == nil { 3177 return nil 3178 } 3179 invalidParams := smithy.InvalidParamsError{Context: "UpdateBotAliasInput"} 3180 if v.BotAliasId == nil { 3181 invalidParams.Add(smithy.NewErrParamRequired("BotAliasId")) 3182 } 3183 if v.BotAliasName == nil { 3184 invalidParams.Add(smithy.NewErrParamRequired("BotAliasName")) 3185 } 3186 if v.BotAliasLocaleSettings != nil { 3187 if err := validateBotAliasLocaleSettingsMap(v.BotAliasLocaleSettings); err != nil { 3188 invalidParams.AddNested("BotAliasLocaleSettings", err.(smithy.InvalidParamsError)) 3189 } 3190 } 3191 if v.ConversationLogSettings != nil { 3192 if err := validateConversationLogSettings(v.ConversationLogSettings); err != nil { 3193 invalidParams.AddNested("ConversationLogSettings", err.(smithy.InvalidParamsError)) 3194 } 3195 } 3196 if v.SentimentAnalysisSettings != nil { 3197 if err := validateSentimentAnalysisSettings(v.SentimentAnalysisSettings); err != nil { 3198 invalidParams.AddNested("SentimentAnalysisSettings", err.(smithy.InvalidParamsError)) 3199 } 3200 } 3201 if v.BotId == nil { 3202 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3203 } 3204 if invalidParams.Len() > 0 { 3205 return invalidParams 3206 } else { 3207 return nil 3208 } 3209} 3210 3211func validateOpUpdateBotInput(v *UpdateBotInput) error { 3212 if v == nil { 3213 return nil 3214 } 3215 invalidParams := smithy.InvalidParamsError{Context: "UpdateBotInput"} 3216 if v.BotId == nil { 3217 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3218 } 3219 if v.BotName == nil { 3220 invalidParams.Add(smithy.NewErrParamRequired("BotName")) 3221 } 3222 if v.RoleArn == nil { 3223 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 3224 } 3225 if v.DataPrivacy == nil { 3226 invalidParams.Add(smithy.NewErrParamRequired("DataPrivacy")) 3227 } else if v.DataPrivacy != nil { 3228 if err := validateDataPrivacy(v.DataPrivacy); err != nil { 3229 invalidParams.AddNested("DataPrivacy", err.(smithy.InvalidParamsError)) 3230 } 3231 } 3232 if v.IdleSessionTTLInSeconds == nil { 3233 invalidParams.Add(smithy.NewErrParamRequired("IdleSessionTTLInSeconds")) 3234 } 3235 if invalidParams.Len() > 0 { 3236 return invalidParams 3237 } else { 3238 return nil 3239 } 3240} 3241 3242func validateOpUpdateBotLocaleInput(v *UpdateBotLocaleInput) error { 3243 if v == nil { 3244 return nil 3245 } 3246 invalidParams := smithy.InvalidParamsError{Context: "UpdateBotLocaleInput"} 3247 if v.BotId == nil { 3248 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3249 } 3250 if v.BotVersion == nil { 3251 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 3252 } 3253 if v.LocaleId == nil { 3254 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 3255 } 3256 if v.NluIntentConfidenceThreshold == nil { 3257 invalidParams.Add(smithy.NewErrParamRequired("NluIntentConfidenceThreshold")) 3258 } 3259 if v.VoiceSettings != nil { 3260 if err := validateVoiceSettings(v.VoiceSettings); err != nil { 3261 invalidParams.AddNested("VoiceSettings", err.(smithy.InvalidParamsError)) 3262 } 3263 } 3264 if invalidParams.Len() > 0 { 3265 return invalidParams 3266 } else { 3267 return nil 3268 } 3269} 3270 3271func validateOpUpdateIntentInput(v *UpdateIntentInput) error { 3272 if v == nil { 3273 return nil 3274 } 3275 invalidParams := smithy.InvalidParamsError{Context: "UpdateIntentInput"} 3276 if v.IntentId == nil { 3277 invalidParams.Add(smithy.NewErrParamRequired("IntentId")) 3278 } 3279 if v.IntentName == nil { 3280 invalidParams.Add(smithy.NewErrParamRequired("IntentName")) 3281 } 3282 if v.SampleUtterances != nil { 3283 if err := validateSampleUtterancesList(v.SampleUtterances); err != nil { 3284 invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError)) 3285 } 3286 } 3287 if v.DialogCodeHook != nil { 3288 if err := validateDialogCodeHookSettings(v.DialogCodeHook); err != nil { 3289 invalidParams.AddNested("DialogCodeHook", err.(smithy.InvalidParamsError)) 3290 } 3291 } 3292 if v.FulfillmentCodeHook != nil { 3293 if err := validateFulfillmentCodeHookSettings(v.FulfillmentCodeHook); err != nil { 3294 invalidParams.AddNested("FulfillmentCodeHook", err.(smithy.InvalidParamsError)) 3295 } 3296 } 3297 if v.SlotPriorities != nil { 3298 if err := validateSlotPrioritiesList(v.SlotPriorities); err != nil { 3299 invalidParams.AddNested("SlotPriorities", err.(smithy.InvalidParamsError)) 3300 } 3301 } 3302 if v.IntentConfirmationSetting != nil { 3303 if err := validateIntentConfirmationSetting(v.IntentConfirmationSetting); err != nil { 3304 invalidParams.AddNested("IntentConfirmationSetting", err.(smithy.InvalidParamsError)) 3305 } 3306 } 3307 if v.IntentClosingSetting != nil { 3308 if err := validateIntentClosingSetting(v.IntentClosingSetting); err != nil { 3309 invalidParams.AddNested("IntentClosingSetting", err.(smithy.InvalidParamsError)) 3310 } 3311 } 3312 if v.InputContexts != nil { 3313 if err := validateInputContextsList(v.InputContexts); err != nil { 3314 invalidParams.AddNested("InputContexts", err.(smithy.InvalidParamsError)) 3315 } 3316 } 3317 if v.OutputContexts != nil { 3318 if err := validateOutputContextsList(v.OutputContexts); err != nil { 3319 invalidParams.AddNested("OutputContexts", err.(smithy.InvalidParamsError)) 3320 } 3321 } 3322 if v.KendraConfiguration != nil { 3323 if err := validateKendraConfiguration(v.KendraConfiguration); err != nil { 3324 invalidParams.AddNested("KendraConfiguration", err.(smithy.InvalidParamsError)) 3325 } 3326 } 3327 if v.BotId == nil { 3328 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3329 } 3330 if v.BotVersion == nil { 3331 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 3332 } 3333 if v.LocaleId == nil { 3334 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 3335 } 3336 if invalidParams.Len() > 0 { 3337 return invalidParams 3338 } else { 3339 return nil 3340 } 3341} 3342 3343func validateOpUpdateSlotInput(v *UpdateSlotInput) error { 3344 if v == nil { 3345 return nil 3346 } 3347 invalidParams := smithy.InvalidParamsError{Context: "UpdateSlotInput"} 3348 if v.SlotId == nil { 3349 invalidParams.Add(smithy.NewErrParamRequired("SlotId")) 3350 } 3351 if v.SlotName == nil { 3352 invalidParams.Add(smithy.NewErrParamRequired("SlotName")) 3353 } 3354 if v.SlotTypeId == nil { 3355 invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId")) 3356 } 3357 if v.ValueElicitationSetting == nil { 3358 invalidParams.Add(smithy.NewErrParamRequired("ValueElicitationSetting")) 3359 } else if v.ValueElicitationSetting != nil { 3360 if err := validateSlotValueElicitationSetting(v.ValueElicitationSetting); err != nil { 3361 invalidParams.AddNested("ValueElicitationSetting", err.(smithy.InvalidParamsError)) 3362 } 3363 } 3364 if v.ObfuscationSetting != nil { 3365 if err := validateObfuscationSetting(v.ObfuscationSetting); err != nil { 3366 invalidParams.AddNested("ObfuscationSetting", err.(smithy.InvalidParamsError)) 3367 } 3368 } 3369 if v.BotId == nil { 3370 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3371 } 3372 if v.BotVersion == nil { 3373 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 3374 } 3375 if v.LocaleId == nil { 3376 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 3377 } 3378 if v.IntentId == nil { 3379 invalidParams.Add(smithy.NewErrParamRequired("IntentId")) 3380 } 3381 if invalidParams.Len() > 0 { 3382 return invalidParams 3383 } else { 3384 return nil 3385 } 3386} 3387 3388func validateOpUpdateSlotTypeInput(v *UpdateSlotTypeInput) error { 3389 if v == nil { 3390 return nil 3391 } 3392 invalidParams := smithy.InvalidParamsError{Context: "UpdateSlotTypeInput"} 3393 if v.SlotTypeId == nil { 3394 invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId")) 3395 } 3396 if v.SlotTypeName == nil { 3397 invalidParams.Add(smithy.NewErrParamRequired("SlotTypeName")) 3398 } 3399 if v.SlotTypeValues != nil { 3400 if err := validateSlotTypeValues(v.SlotTypeValues); err != nil { 3401 invalidParams.AddNested("SlotTypeValues", err.(smithy.InvalidParamsError)) 3402 } 3403 } 3404 if v.ValueSelectionSetting == nil { 3405 invalidParams.Add(smithy.NewErrParamRequired("ValueSelectionSetting")) 3406 } else if v.ValueSelectionSetting != nil { 3407 if err := validateSlotValueSelectionSetting(v.ValueSelectionSetting); err != nil { 3408 invalidParams.AddNested("ValueSelectionSetting", err.(smithy.InvalidParamsError)) 3409 } 3410 } 3411 if v.BotId == nil { 3412 invalidParams.Add(smithy.NewErrParamRequired("BotId")) 3413 } 3414 if v.BotVersion == nil { 3415 invalidParams.Add(smithy.NewErrParamRequired("BotVersion")) 3416 } 3417 if v.LocaleId == nil { 3418 invalidParams.Add(smithy.NewErrParamRequired("LocaleId")) 3419 } 3420 if invalidParams.Len() > 0 { 3421 return invalidParams 3422 } else { 3423 return nil 3424 } 3425} 3426