1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package kendra 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/kendra/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpBatchDeleteDocument struct { 14} 15 16func (*validateOpBatchDeleteDocument) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpBatchDeleteDocument) 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.(*BatchDeleteDocumentInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpBatchDeleteDocumentInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpBatchPutDocument struct { 34} 35 36func (*validateOpBatchPutDocument) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpBatchPutDocument) 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.(*BatchPutDocumentInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpBatchPutDocumentInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateDataSource struct { 54} 55 56func (*validateOpCreateDataSource) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateDataSource) 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.(*CreateDataSourceInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateDataSourceInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateFaq struct { 74} 75 76func (*validateOpCreateFaq) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateFaq) 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.(*CreateFaqInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateFaqInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateIndex struct { 94} 95 96func (*validateOpCreateIndex) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateIndex) 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.(*CreateIndexInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateIndexInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateThesaurus struct { 114} 115 116func (*validateOpCreateThesaurus) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateThesaurus) 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.(*CreateThesaurusInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateThesaurusInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteDataSource struct { 134} 135 136func (*validateOpDeleteDataSource) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteDataSource) 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.(*DeleteDataSourceInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteDataSourceInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteFaq struct { 154} 155 156func (*validateOpDeleteFaq) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteFaq) 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.(*DeleteFaqInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteFaqInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteIndex struct { 174} 175 176func (*validateOpDeleteIndex) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteIndex) 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.(*DeleteIndexInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteIndexInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteThesaurus struct { 194} 195 196func (*validateOpDeleteThesaurus) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteThesaurus) 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.(*DeleteThesaurusInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteThesaurusInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDescribeDataSource struct { 214} 215 216func (*validateOpDescribeDataSource) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDescribeDataSource) 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.(*DescribeDataSourceInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDescribeDataSourceInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDescribeFaq struct { 234} 235 236func (*validateOpDescribeFaq) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDescribeFaq) 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.(*DescribeFaqInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDescribeFaqInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDescribeIndex struct { 254} 255 256func (*validateOpDescribeIndex) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDescribeIndex) 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.(*DescribeIndexInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDescribeIndexInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDescribeThesaurus struct { 274} 275 276func (*validateOpDescribeThesaurus) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDescribeThesaurus) 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.(*DescribeThesaurusInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDescribeThesaurusInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpListDataSources struct { 294} 295 296func (*validateOpListDataSources) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpListDataSources) 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.(*ListDataSourcesInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpListDataSourcesInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpListDataSourceSyncJobs struct { 314} 315 316func (*validateOpListDataSourceSyncJobs) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpListDataSourceSyncJobs) 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.(*ListDataSourceSyncJobsInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpListDataSourceSyncJobsInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpListFaqs struct { 334} 335 336func (*validateOpListFaqs) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpListFaqs) 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.(*ListFaqsInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpListFaqsInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpListTagsForResource struct { 354} 355 356func (*validateOpListTagsForResource) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpListTagsForResourceInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpListThesauri struct { 374} 375 376func (*validateOpListThesauri) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpListThesauri) 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.(*ListThesauriInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpListThesauriInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpQuery struct { 394} 395 396func (*validateOpQuery) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpQuery) 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.(*QueryInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpQueryInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpStartDataSourceSyncJob struct { 414} 415 416func (*validateOpStartDataSourceSyncJob) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpStartDataSourceSyncJob) 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.(*StartDataSourceSyncJobInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpStartDataSourceSyncJobInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpStopDataSourceSyncJob struct { 434} 435 436func (*validateOpStopDataSourceSyncJob) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpStopDataSourceSyncJob) 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.(*StopDataSourceSyncJobInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpStopDataSourceSyncJobInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpSubmitFeedback struct { 454} 455 456func (*validateOpSubmitFeedback) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpSubmitFeedback) 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.(*SubmitFeedbackInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpSubmitFeedbackInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpTagResource struct { 474} 475 476func (*validateOpTagResource) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpTagResource) 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.(*TagResourceInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpTagResourceInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpUntagResource struct { 494} 495 496func (*validateOpUntagResource) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpUntagResource) 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.(*UntagResourceInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpUntagResourceInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpUpdateDataSource struct { 514} 515 516func (*validateOpUpdateDataSource) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpUpdateDataSource) 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.(*UpdateDataSourceInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpUpdateDataSourceInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpUpdateIndex struct { 534} 535 536func (*validateOpUpdateIndex) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpUpdateIndex) 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.(*UpdateIndexInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpUpdateIndexInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpUpdateThesaurus struct { 554} 555 556func (*validateOpUpdateThesaurus) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpUpdateThesaurus) 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.(*UpdateThesaurusInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpUpdateThesaurusInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573func addOpBatchDeleteDocumentValidationMiddleware(stack *middleware.Stack) error { 574 return stack.Initialize.Add(&validateOpBatchDeleteDocument{}, middleware.After) 575} 576 577func addOpBatchPutDocumentValidationMiddleware(stack *middleware.Stack) error { 578 return stack.Initialize.Add(&validateOpBatchPutDocument{}, middleware.After) 579} 580 581func addOpCreateDataSourceValidationMiddleware(stack *middleware.Stack) error { 582 return stack.Initialize.Add(&validateOpCreateDataSource{}, middleware.After) 583} 584 585func addOpCreateFaqValidationMiddleware(stack *middleware.Stack) error { 586 return stack.Initialize.Add(&validateOpCreateFaq{}, middleware.After) 587} 588 589func addOpCreateIndexValidationMiddleware(stack *middleware.Stack) error { 590 return stack.Initialize.Add(&validateOpCreateIndex{}, middleware.After) 591} 592 593func addOpCreateThesaurusValidationMiddleware(stack *middleware.Stack) error { 594 return stack.Initialize.Add(&validateOpCreateThesaurus{}, middleware.After) 595} 596 597func addOpDeleteDataSourceValidationMiddleware(stack *middleware.Stack) error { 598 return stack.Initialize.Add(&validateOpDeleteDataSource{}, middleware.After) 599} 600 601func addOpDeleteFaqValidationMiddleware(stack *middleware.Stack) error { 602 return stack.Initialize.Add(&validateOpDeleteFaq{}, middleware.After) 603} 604 605func addOpDeleteIndexValidationMiddleware(stack *middleware.Stack) error { 606 return stack.Initialize.Add(&validateOpDeleteIndex{}, middleware.After) 607} 608 609func addOpDeleteThesaurusValidationMiddleware(stack *middleware.Stack) error { 610 return stack.Initialize.Add(&validateOpDeleteThesaurus{}, middleware.After) 611} 612 613func addOpDescribeDataSourceValidationMiddleware(stack *middleware.Stack) error { 614 return stack.Initialize.Add(&validateOpDescribeDataSource{}, middleware.After) 615} 616 617func addOpDescribeFaqValidationMiddleware(stack *middleware.Stack) error { 618 return stack.Initialize.Add(&validateOpDescribeFaq{}, middleware.After) 619} 620 621func addOpDescribeIndexValidationMiddleware(stack *middleware.Stack) error { 622 return stack.Initialize.Add(&validateOpDescribeIndex{}, middleware.After) 623} 624 625func addOpDescribeThesaurusValidationMiddleware(stack *middleware.Stack) error { 626 return stack.Initialize.Add(&validateOpDescribeThesaurus{}, middleware.After) 627} 628 629func addOpListDataSourcesValidationMiddleware(stack *middleware.Stack) error { 630 return stack.Initialize.Add(&validateOpListDataSources{}, middleware.After) 631} 632 633func addOpListDataSourceSyncJobsValidationMiddleware(stack *middleware.Stack) error { 634 return stack.Initialize.Add(&validateOpListDataSourceSyncJobs{}, middleware.After) 635} 636 637func addOpListFaqsValidationMiddleware(stack *middleware.Stack) error { 638 return stack.Initialize.Add(&validateOpListFaqs{}, middleware.After) 639} 640 641func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 642 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 643} 644 645func addOpListThesauriValidationMiddleware(stack *middleware.Stack) error { 646 return stack.Initialize.Add(&validateOpListThesauri{}, middleware.After) 647} 648 649func addOpQueryValidationMiddleware(stack *middleware.Stack) error { 650 return stack.Initialize.Add(&validateOpQuery{}, middleware.After) 651} 652 653func addOpStartDataSourceSyncJobValidationMiddleware(stack *middleware.Stack) error { 654 return stack.Initialize.Add(&validateOpStartDataSourceSyncJob{}, middleware.After) 655} 656 657func addOpStopDataSourceSyncJobValidationMiddleware(stack *middleware.Stack) error { 658 return stack.Initialize.Add(&validateOpStopDataSourceSyncJob{}, middleware.After) 659} 660 661func addOpSubmitFeedbackValidationMiddleware(stack *middleware.Stack) error { 662 return stack.Initialize.Add(&validateOpSubmitFeedback{}, middleware.After) 663} 664 665func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 666 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 667} 668 669func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 670 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 671} 672 673func addOpUpdateDataSourceValidationMiddleware(stack *middleware.Stack) error { 674 return stack.Initialize.Add(&validateOpUpdateDataSource{}, middleware.After) 675} 676 677func addOpUpdateIndexValidationMiddleware(stack *middleware.Stack) error { 678 return stack.Initialize.Add(&validateOpUpdateIndex{}, middleware.After) 679} 680 681func addOpUpdateThesaurusValidationMiddleware(stack *middleware.Stack) error { 682 return stack.Initialize.Add(&validateOpUpdateThesaurus{}, middleware.After) 683} 684 685func validateAclConfiguration(v *types.AclConfiguration) error { 686 if v == nil { 687 return nil 688 } 689 invalidParams := smithy.InvalidParamsError{Context: "AclConfiguration"} 690 if v.AllowedGroupsColumnName == nil { 691 invalidParams.Add(smithy.NewErrParamRequired("AllowedGroupsColumnName")) 692 } 693 if invalidParams.Len() > 0 { 694 return invalidParams 695 } else { 696 return nil 697 } 698} 699 700func validateAttributeFilter(v *types.AttributeFilter) error { 701 if v == nil { 702 return nil 703 } 704 invalidParams := smithy.InvalidParamsError{Context: "AttributeFilter"} 705 if v.AndAllFilters != nil { 706 if err := validateAttributeFilterList(v.AndAllFilters); err != nil { 707 invalidParams.AddNested("AndAllFilters", err.(smithy.InvalidParamsError)) 708 } 709 } 710 if v.OrAllFilters != nil { 711 if err := validateAttributeFilterList(v.OrAllFilters); err != nil { 712 invalidParams.AddNested("OrAllFilters", err.(smithy.InvalidParamsError)) 713 } 714 } 715 if v.NotFilter != nil { 716 if err := validateAttributeFilter(v.NotFilter); err != nil { 717 invalidParams.AddNested("NotFilter", err.(smithy.InvalidParamsError)) 718 } 719 } 720 if v.EqualsTo != nil { 721 if err := validateDocumentAttribute(v.EqualsTo); err != nil { 722 invalidParams.AddNested("EqualsTo", err.(smithy.InvalidParamsError)) 723 } 724 } 725 if v.ContainsAll != nil { 726 if err := validateDocumentAttribute(v.ContainsAll); err != nil { 727 invalidParams.AddNested("ContainsAll", err.(smithy.InvalidParamsError)) 728 } 729 } 730 if v.ContainsAny != nil { 731 if err := validateDocumentAttribute(v.ContainsAny); err != nil { 732 invalidParams.AddNested("ContainsAny", err.(smithy.InvalidParamsError)) 733 } 734 } 735 if v.GreaterThan != nil { 736 if err := validateDocumentAttribute(v.GreaterThan); err != nil { 737 invalidParams.AddNested("GreaterThan", err.(smithy.InvalidParamsError)) 738 } 739 } 740 if v.GreaterThanOrEquals != nil { 741 if err := validateDocumentAttribute(v.GreaterThanOrEquals); err != nil { 742 invalidParams.AddNested("GreaterThanOrEquals", err.(smithy.InvalidParamsError)) 743 } 744 } 745 if v.LessThan != nil { 746 if err := validateDocumentAttribute(v.LessThan); err != nil { 747 invalidParams.AddNested("LessThan", err.(smithy.InvalidParamsError)) 748 } 749 } 750 if v.LessThanOrEquals != nil { 751 if err := validateDocumentAttribute(v.LessThanOrEquals); err != nil { 752 invalidParams.AddNested("LessThanOrEquals", err.(smithy.InvalidParamsError)) 753 } 754 } 755 if invalidParams.Len() > 0 { 756 return invalidParams 757 } else { 758 return nil 759 } 760} 761 762func validateAttributeFilterList(v []types.AttributeFilter) error { 763 if v == nil { 764 return nil 765 } 766 invalidParams := smithy.InvalidParamsError{Context: "AttributeFilterList"} 767 for i := range v { 768 if err := validateAttributeFilter(&v[i]); err != nil { 769 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 770 } 771 } 772 if invalidParams.Len() > 0 { 773 return invalidParams 774 } else { 775 return nil 776 } 777} 778 779func validateCapacityUnitsConfiguration(v *types.CapacityUnitsConfiguration) error { 780 if v == nil { 781 return nil 782 } 783 invalidParams := smithy.InvalidParamsError{Context: "CapacityUnitsConfiguration"} 784 if v.StorageCapacityUnits == nil { 785 invalidParams.Add(smithy.NewErrParamRequired("StorageCapacityUnits")) 786 } 787 if v.QueryCapacityUnits == nil { 788 invalidParams.Add(smithy.NewErrParamRequired("QueryCapacityUnits")) 789 } 790 if invalidParams.Len() > 0 { 791 return invalidParams 792 } else { 793 return nil 794 } 795} 796 797func validateClickFeedback(v *types.ClickFeedback) error { 798 if v == nil { 799 return nil 800 } 801 invalidParams := smithy.InvalidParamsError{Context: "ClickFeedback"} 802 if v.ResultId == nil { 803 invalidParams.Add(smithy.NewErrParamRequired("ResultId")) 804 } 805 if v.ClickTime == nil { 806 invalidParams.Add(smithy.NewErrParamRequired("ClickTime")) 807 } 808 if invalidParams.Len() > 0 { 809 return invalidParams 810 } else { 811 return nil 812 } 813} 814 815func validateClickFeedbackList(v []types.ClickFeedback) error { 816 if v == nil { 817 return nil 818 } 819 invalidParams := smithy.InvalidParamsError{Context: "ClickFeedbackList"} 820 for i := range v { 821 if err := validateClickFeedback(&v[i]); err != nil { 822 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 823 } 824 } 825 if invalidParams.Len() > 0 { 826 return invalidParams 827 } else { 828 return nil 829 } 830} 831 832func validateColumnConfiguration(v *types.ColumnConfiguration) error { 833 if v == nil { 834 return nil 835 } 836 invalidParams := smithy.InvalidParamsError{Context: "ColumnConfiguration"} 837 if v.DocumentIdColumnName == nil { 838 invalidParams.Add(smithy.NewErrParamRequired("DocumentIdColumnName")) 839 } 840 if v.DocumentDataColumnName == nil { 841 invalidParams.Add(smithy.NewErrParamRequired("DocumentDataColumnName")) 842 } 843 if v.FieldMappings != nil { 844 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 845 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 846 } 847 } 848 if v.ChangeDetectingColumns == nil { 849 invalidParams.Add(smithy.NewErrParamRequired("ChangeDetectingColumns")) 850 } 851 if invalidParams.Len() > 0 { 852 return invalidParams 853 } else { 854 return nil 855 } 856} 857 858func validateConfluenceConfiguration(v *types.ConfluenceConfiguration) error { 859 if v == nil { 860 return nil 861 } 862 invalidParams := smithy.InvalidParamsError{Context: "ConfluenceConfiguration"} 863 if v.ServerUrl == nil { 864 invalidParams.Add(smithy.NewErrParamRequired("ServerUrl")) 865 } 866 if v.SecretArn == nil { 867 invalidParams.Add(smithy.NewErrParamRequired("SecretArn")) 868 } 869 if len(v.Version) == 0 { 870 invalidParams.Add(smithy.NewErrParamRequired("Version")) 871 } 872 if v.VpcConfiguration != nil { 873 if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil { 874 invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError)) 875 } 876 } 877 if invalidParams.Len() > 0 { 878 return invalidParams 879 } else { 880 return nil 881 } 882} 883 884func validateConnectionConfiguration(v *types.ConnectionConfiguration) error { 885 if v == nil { 886 return nil 887 } 888 invalidParams := smithy.InvalidParamsError{Context: "ConnectionConfiguration"} 889 if v.DatabaseHost == nil { 890 invalidParams.Add(smithy.NewErrParamRequired("DatabaseHost")) 891 } 892 if v.DatabasePort == nil { 893 invalidParams.Add(smithy.NewErrParamRequired("DatabasePort")) 894 } 895 if v.DatabaseName == nil { 896 invalidParams.Add(smithy.NewErrParamRequired("DatabaseName")) 897 } 898 if v.TableName == nil { 899 invalidParams.Add(smithy.NewErrParamRequired("TableName")) 900 } 901 if v.SecretArn == nil { 902 invalidParams.Add(smithy.NewErrParamRequired("SecretArn")) 903 } 904 if invalidParams.Len() > 0 { 905 return invalidParams 906 } else { 907 return nil 908 } 909} 910 911func validateDatabaseConfiguration(v *types.DatabaseConfiguration) error { 912 if v == nil { 913 return nil 914 } 915 invalidParams := smithy.InvalidParamsError{Context: "DatabaseConfiguration"} 916 if len(v.DatabaseEngineType) == 0 { 917 invalidParams.Add(smithy.NewErrParamRequired("DatabaseEngineType")) 918 } 919 if v.ConnectionConfiguration == nil { 920 invalidParams.Add(smithy.NewErrParamRequired("ConnectionConfiguration")) 921 } else if v.ConnectionConfiguration != nil { 922 if err := validateConnectionConfiguration(v.ConnectionConfiguration); err != nil { 923 invalidParams.AddNested("ConnectionConfiguration", err.(smithy.InvalidParamsError)) 924 } 925 } 926 if v.VpcConfiguration != nil { 927 if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil { 928 invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError)) 929 } 930 } 931 if v.ColumnConfiguration == nil { 932 invalidParams.Add(smithy.NewErrParamRequired("ColumnConfiguration")) 933 } else if v.ColumnConfiguration != nil { 934 if err := validateColumnConfiguration(v.ColumnConfiguration); err != nil { 935 invalidParams.AddNested("ColumnConfiguration", err.(smithy.InvalidParamsError)) 936 } 937 } 938 if v.AclConfiguration != nil { 939 if err := validateAclConfiguration(v.AclConfiguration); err != nil { 940 invalidParams.AddNested("AclConfiguration", err.(smithy.InvalidParamsError)) 941 } 942 } 943 if invalidParams.Len() > 0 { 944 return invalidParams 945 } else { 946 return nil 947 } 948} 949 950func validateDataSourceConfiguration(v *types.DataSourceConfiguration) error { 951 if v == nil { 952 return nil 953 } 954 invalidParams := smithy.InvalidParamsError{Context: "DataSourceConfiguration"} 955 if v.S3Configuration != nil { 956 if err := validateS3DataSourceConfiguration(v.S3Configuration); err != nil { 957 invalidParams.AddNested("S3Configuration", err.(smithy.InvalidParamsError)) 958 } 959 } 960 if v.SharePointConfiguration != nil { 961 if err := validateSharePointConfiguration(v.SharePointConfiguration); err != nil { 962 invalidParams.AddNested("SharePointConfiguration", err.(smithy.InvalidParamsError)) 963 } 964 } 965 if v.DatabaseConfiguration != nil { 966 if err := validateDatabaseConfiguration(v.DatabaseConfiguration); err != nil { 967 invalidParams.AddNested("DatabaseConfiguration", err.(smithy.InvalidParamsError)) 968 } 969 } 970 if v.SalesforceConfiguration != nil { 971 if err := validateSalesforceConfiguration(v.SalesforceConfiguration); err != nil { 972 invalidParams.AddNested("SalesforceConfiguration", err.(smithy.InvalidParamsError)) 973 } 974 } 975 if v.OneDriveConfiguration != nil { 976 if err := validateOneDriveConfiguration(v.OneDriveConfiguration); err != nil { 977 invalidParams.AddNested("OneDriveConfiguration", err.(smithy.InvalidParamsError)) 978 } 979 } 980 if v.ServiceNowConfiguration != nil { 981 if err := validateServiceNowConfiguration(v.ServiceNowConfiguration); err != nil { 982 invalidParams.AddNested("ServiceNowConfiguration", err.(smithy.InvalidParamsError)) 983 } 984 } 985 if v.ConfluenceConfiguration != nil { 986 if err := validateConfluenceConfiguration(v.ConfluenceConfiguration); err != nil { 987 invalidParams.AddNested("ConfluenceConfiguration", err.(smithy.InvalidParamsError)) 988 } 989 } 990 if v.GoogleDriveConfiguration != nil { 991 if err := validateGoogleDriveConfiguration(v.GoogleDriveConfiguration); err != nil { 992 invalidParams.AddNested("GoogleDriveConfiguration", err.(smithy.InvalidParamsError)) 993 } 994 } 995 if invalidParams.Len() > 0 { 996 return invalidParams 997 } else { 998 return nil 999 } 1000} 1001 1002func validateDataSourceSyncJobMetricTarget(v *types.DataSourceSyncJobMetricTarget) error { 1003 if v == nil { 1004 return nil 1005 } 1006 invalidParams := smithy.InvalidParamsError{Context: "DataSourceSyncJobMetricTarget"} 1007 if v.DataSourceId == nil { 1008 invalidParams.Add(smithy.NewErrParamRequired("DataSourceId")) 1009 } 1010 if v.DataSourceSyncJobId == nil { 1011 invalidParams.Add(smithy.NewErrParamRequired("DataSourceSyncJobId")) 1012 } 1013 if invalidParams.Len() > 0 { 1014 return invalidParams 1015 } else { 1016 return nil 1017 } 1018} 1019 1020func validateDataSourceToIndexFieldMapping(v *types.DataSourceToIndexFieldMapping) error { 1021 if v == nil { 1022 return nil 1023 } 1024 invalidParams := smithy.InvalidParamsError{Context: "DataSourceToIndexFieldMapping"} 1025 if v.DataSourceFieldName == nil { 1026 invalidParams.Add(smithy.NewErrParamRequired("DataSourceFieldName")) 1027 } 1028 if v.IndexFieldName == nil { 1029 invalidParams.Add(smithy.NewErrParamRequired("IndexFieldName")) 1030 } 1031 if invalidParams.Len() > 0 { 1032 return invalidParams 1033 } else { 1034 return nil 1035 } 1036} 1037 1038func validateDataSourceToIndexFieldMappingList(v []types.DataSourceToIndexFieldMapping) error { 1039 if v == nil { 1040 return nil 1041 } 1042 invalidParams := smithy.InvalidParamsError{Context: "DataSourceToIndexFieldMappingList"} 1043 for i := range v { 1044 if err := validateDataSourceToIndexFieldMapping(&v[i]); err != nil { 1045 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1046 } 1047 } 1048 if invalidParams.Len() > 0 { 1049 return invalidParams 1050 } else { 1051 return nil 1052 } 1053} 1054 1055func validateDataSourceVpcConfiguration(v *types.DataSourceVpcConfiguration) error { 1056 if v == nil { 1057 return nil 1058 } 1059 invalidParams := smithy.InvalidParamsError{Context: "DataSourceVpcConfiguration"} 1060 if v.SubnetIds == nil { 1061 invalidParams.Add(smithy.NewErrParamRequired("SubnetIds")) 1062 } 1063 if v.SecurityGroupIds == nil { 1064 invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds")) 1065 } 1066 if invalidParams.Len() > 0 { 1067 return invalidParams 1068 } else { 1069 return nil 1070 } 1071} 1072 1073func validateDocument(v *types.Document) error { 1074 if v == nil { 1075 return nil 1076 } 1077 invalidParams := smithy.InvalidParamsError{Context: "Document"} 1078 if v.Id == nil { 1079 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1080 } 1081 if v.S3Path != nil { 1082 if err := validateS3Path(v.S3Path); err != nil { 1083 invalidParams.AddNested("S3Path", err.(smithy.InvalidParamsError)) 1084 } 1085 } 1086 if v.Attributes != nil { 1087 if err := validateDocumentAttributeList(v.Attributes); err != nil { 1088 invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError)) 1089 } 1090 } 1091 if v.AccessControlList != nil { 1092 if err := validatePrincipalList(v.AccessControlList); err != nil { 1093 invalidParams.AddNested("AccessControlList", err.(smithy.InvalidParamsError)) 1094 } 1095 } 1096 if invalidParams.Len() > 0 { 1097 return invalidParams 1098 } else { 1099 return nil 1100 } 1101} 1102 1103func validateDocumentAttribute(v *types.DocumentAttribute) error { 1104 if v == nil { 1105 return nil 1106 } 1107 invalidParams := smithy.InvalidParamsError{Context: "DocumentAttribute"} 1108 if v.Key == nil { 1109 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1110 } 1111 if v.Value == nil { 1112 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1113 } 1114 if invalidParams.Len() > 0 { 1115 return invalidParams 1116 } else { 1117 return nil 1118 } 1119} 1120 1121func validateDocumentAttributeList(v []types.DocumentAttribute) error { 1122 if v == nil { 1123 return nil 1124 } 1125 invalidParams := smithy.InvalidParamsError{Context: "DocumentAttributeList"} 1126 for i := range v { 1127 if err := validateDocumentAttribute(&v[i]); err != nil { 1128 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1129 } 1130 } 1131 if invalidParams.Len() > 0 { 1132 return invalidParams 1133 } else { 1134 return nil 1135 } 1136} 1137 1138func validateDocumentList(v []types.Document) error { 1139 if v == nil { 1140 return nil 1141 } 1142 invalidParams := smithy.InvalidParamsError{Context: "DocumentList"} 1143 for i := range v { 1144 if err := validateDocument(&v[i]); err != nil { 1145 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1146 } 1147 } 1148 if invalidParams.Len() > 0 { 1149 return invalidParams 1150 } else { 1151 return nil 1152 } 1153} 1154 1155func validateDocumentMetadataConfiguration(v *types.DocumentMetadataConfiguration) error { 1156 if v == nil { 1157 return nil 1158 } 1159 invalidParams := smithy.InvalidParamsError{Context: "DocumentMetadataConfiguration"} 1160 if v.Name == nil { 1161 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1162 } 1163 if len(v.Type) == 0 { 1164 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1165 } 1166 if invalidParams.Len() > 0 { 1167 return invalidParams 1168 } else { 1169 return nil 1170 } 1171} 1172 1173func validateDocumentMetadataConfigurationList(v []types.DocumentMetadataConfiguration) error { 1174 if v == nil { 1175 return nil 1176 } 1177 invalidParams := smithy.InvalidParamsError{Context: "DocumentMetadataConfigurationList"} 1178 for i := range v { 1179 if err := validateDocumentMetadataConfiguration(&v[i]); err != nil { 1180 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1181 } 1182 } 1183 if invalidParams.Len() > 0 { 1184 return invalidParams 1185 } else { 1186 return nil 1187 } 1188} 1189 1190func validateGoogleDriveConfiguration(v *types.GoogleDriveConfiguration) error { 1191 if v == nil { 1192 return nil 1193 } 1194 invalidParams := smithy.InvalidParamsError{Context: "GoogleDriveConfiguration"} 1195 if v.SecretArn == nil { 1196 invalidParams.Add(smithy.NewErrParamRequired("SecretArn")) 1197 } 1198 if v.FieldMappings != nil { 1199 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1200 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1201 } 1202 } 1203 if invalidParams.Len() > 0 { 1204 return invalidParams 1205 } else { 1206 return nil 1207 } 1208} 1209 1210func validateJsonTokenTypeConfiguration(v *types.JsonTokenTypeConfiguration) error { 1211 if v == nil { 1212 return nil 1213 } 1214 invalidParams := smithy.InvalidParamsError{Context: "JsonTokenTypeConfiguration"} 1215 if v.UserNameAttributeField == nil { 1216 invalidParams.Add(smithy.NewErrParamRequired("UserNameAttributeField")) 1217 } 1218 if v.GroupAttributeField == nil { 1219 invalidParams.Add(smithy.NewErrParamRequired("GroupAttributeField")) 1220 } 1221 if invalidParams.Len() > 0 { 1222 return invalidParams 1223 } else { 1224 return nil 1225 } 1226} 1227 1228func validateJwtTokenTypeConfiguration(v *types.JwtTokenTypeConfiguration) error { 1229 if v == nil { 1230 return nil 1231 } 1232 invalidParams := smithy.InvalidParamsError{Context: "JwtTokenTypeConfiguration"} 1233 if len(v.KeyLocation) == 0 { 1234 invalidParams.Add(smithy.NewErrParamRequired("KeyLocation")) 1235 } 1236 if invalidParams.Len() > 0 { 1237 return invalidParams 1238 } else { 1239 return nil 1240 } 1241} 1242 1243func validateOneDriveConfiguration(v *types.OneDriveConfiguration) error { 1244 if v == nil { 1245 return nil 1246 } 1247 invalidParams := smithy.InvalidParamsError{Context: "OneDriveConfiguration"} 1248 if v.TenantDomain == nil { 1249 invalidParams.Add(smithy.NewErrParamRequired("TenantDomain")) 1250 } 1251 if v.SecretArn == nil { 1252 invalidParams.Add(smithy.NewErrParamRequired("SecretArn")) 1253 } 1254 if v.OneDriveUsers == nil { 1255 invalidParams.Add(smithy.NewErrParamRequired("OneDriveUsers")) 1256 } else if v.OneDriveUsers != nil { 1257 if err := validateOneDriveUsers(v.OneDriveUsers); err != nil { 1258 invalidParams.AddNested("OneDriveUsers", err.(smithy.InvalidParamsError)) 1259 } 1260 } 1261 if v.FieldMappings != nil { 1262 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1263 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1264 } 1265 } 1266 if invalidParams.Len() > 0 { 1267 return invalidParams 1268 } else { 1269 return nil 1270 } 1271} 1272 1273func validateOneDriveUsers(v *types.OneDriveUsers) error { 1274 if v == nil { 1275 return nil 1276 } 1277 invalidParams := smithy.InvalidParamsError{Context: "OneDriveUsers"} 1278 if v.OneDriveUserS3Path != nil { 1279 if err := validateS3Path(v.OneDriveUserS3Path); err != nil { 1280 invalidParams.AddNested("OneDriveUserS3Path", err.(smithy.InvalidParamsError)) 1281 } 1282 } 1283 if invalidParams.Len() > 0 { 1284 return invalidParams 1285 } else { 1286 return nil 1287 } 1288} 1289 1290func validatePrincipal(v *types.Principal) error { 1291 if v == nil { 1292 return nil 1293 } 1294 invalidParams := smithy.InvalidParamsError{Context: "Principal"} 1295 if v.Name == nil { 1296 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1297 } 1298 if len(v.Type) == 0 { 1299 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1300 } 1301 if len(v.Access) == 0 { 1302 invalidParams.Add(smithy.NewErrParamRequired("Access")) 1303 } 1304 if invalidParams.Len() > 0 { 1305 return invalidParams 1306 } else { 1307 return nil 1308 } 1309} 1310 1311func validatePrincipalList(v []types.Principal) error { 1312 if v == nil { 1313 return nil 1314 } 1315 invalidParams := smithy.InvalidParamsError{Context: "PrincipalList"} 1316 for i := range v { 1317 if err := validatePrincipal(&v[i]); err != nil { 1318 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1319 } 1320 } 1321 if invalidParams.Len() > 0 { 1322 return invalidParams 1323 } else { 1324 return nil 1325 } 1326} 1327 1328func validateRelevanceFeedback(v *types.RelevanceFeedback) error { 1329 if v == nil { 1330 return nil 1331 } 1332 invalidParams := smithy.InvalidParamsError{Context: "RelevanceFeedback"} 1333 if v.ResultId == nil { 1334 invalidParams.Add(smithy.NewErrParamRequired("ResultId")) 1335 } 1336 if len(v.RelevanceValue) == 0 { 1337 invalidParams.Add(smithy.NewErrParamRequired("RelevanceValue")) 1338 } 1339 if invalidParams.Len() > 0 { 1340 return invalidParams 1341 } else { 1342 return nil 1343 } 1344} 1345 1346func validateRelevanceFeedbackList(v []types.RelevanceFeedback) error { 1347 if v == nil { 1348 return nil 1349 } 1350 invalidParams := smithy.InvalidParamsError{Context: "RelevanceFeedbackList"} 1351 for i := range v { 1352 if err := validateRelevanceFeedback(&v[i]); err != nil { 1353 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1354 } 1355 } 1356 if invalidParams.Len() > 0 { 1357 return invalidParams 1358 } else { 1359 return nil 1360 } 1361} 1362 1363func validateS3DataSourceConfiguration(v *types.S3DataSourceConfiguration) error { 1364 if v == nil { 1365 return nil 1366 } 1367 invalidParams := smithy.InvalidParamsError{Context: "S3DataSourceConfiguration"} 1368 if v.BucketName == nil { 1369 invalidParams.Add(smithy.NewErrParamRequired("BucketName")) 1370 } 1371 if invalidParams.Len() > 0 { 1372 return invalidParams 1373 } else { 1374 return nil 1375 } 1376} 1377 1378func validateS3Path(v *types.S3Path) error { 1379 if v == nil { 1380 return nil 1381 } 1382 invalidParams := smithy.InvalidParamsError{Context: "S3Path"} 1383 if v.Bucket == nil { 1384 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 1385 } 1386 if v.Key == nil { 1387 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1388 } 1389 if invalidParams.Len() > 0 { 1390 return invalidParams 1391 } else { 1392 return nil 1393 } 1394} 1395 1396func validateSalesforceChatterFeedConfiguration(v *types.SalesforceChatterFeedConfiguration) error { 1397 if v == nil { 1398 return nil 1399 } 1400 invalidParams := smithy.InvalidParamsError{Context: "SalesforceChatterFeedConfiguration"} 1401 if v.DocumentDataFieldName == nil { 1402 invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName")) 1403 } 1404 if v.FieldMappings != nil { 1405 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1406 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1407 } 1408 } 1409 if invalidParams.Len() > 0 { 1410 return invalidParams 1411 } else { 1412 return nil 1413 } 1414} 1415 1416func validateSalesforceConfiguration(v *types.SalesforceConfiguration) error { 1417 if v == nil { 1418 return nil 1419 } 1420 invalidParams := smithy.InvalidParamsError{Context: "SalesforceConfiguration"} 1421 if v.ServerUrl == nil { 1422 invalidParams.Add(smithy.NewErrParamRequired("ServerUrl")) 1423 } 1424 if v.SecretArn == nil { 1425 invalidParams.Add(smithy.NewErrParamRequired("SecretArn")) 1426 } 1427 if v.StandardObjectConfigurations != nil { 1428 if err := validateSalesforceStandardObjectConfigurationList(v.StandardObjectConfigurations); err != nil { 1429 invalidParams.AddNested("StandardObjectConfigurations", err.(smithy.InvalidParamsError)) 1430 } 1431 } 1432 if v.KnowledgeArticleConfiguration != nil { 1433 if err := validateSalesforceKnowledgeArticleConfiguration(v.KnowledgeArticleConfiguration); err != nil { 1434 invalidParams.AddNested("KnowledgeArticleConfiguration", err.(smithy.InvalidParamsError)) 1435 } 1436 } 1437 if v.ChatterFeedConfiguration != nil { 1438 if err := validateSalesforceChatterFeedConfiguration(v.ChatterFeedConfiguration); err != nil { 1439 invalidParams.AddNested("ChatterFeedConfiguration", err.(smithy.InvalidParamsError)) 1440 } 1441 } 1442 if v.StandardObjectAttachmentConfiguration != nil { 1443 if err := validateSalesforceStandardObjectAttachmentConfiguration(v.StandardObjectAttachmentConfiguration); err != nil { 1444 invalidParams.AddNested("StandardObjectAttachmentConfiguration", err.(smithy.InvalidParamsError)) 1445 } 1446 } 1447 if invalidParams.Len() > 0 { 1448 return invalidParams 1449 } else { 1450 return nil 1451 } 1452} 1453 1454func validateSalesforceCustomKnowledgeArticleTypeConfiguration(v *types.SalesforceCustomKnowledgeArticleTypeConfiguration) error { 1455 if v == nil { 1456 return nil 1457 } 1458 invalidParams := smithy.InvalidParamsError{Context: "SalesforceCustomKnowledgeArticleTypeConfiguration"} 1459 if v.Name == nil { 1460 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1461 } 1462 if v.DocumentDataFieldName == nil { 1463 invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName")) 1464 } 1465 if v.FieldMappings != nil { 1466 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1467 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1468 } 1469 } 1470 if invalidParams.Len() > 0 { 1471 return invalidParams 1472 } else { 1473 return nil 1474 } 1475} 1476 1477func validateSalesforceCustomKnowledgeArticleTypeConfigurationList(v []types.SalesforceCustomKnowledgeArticleTypeConfiguration) error { 1478 if v == nil { 1479 return nil 1480 } 1481 invalidParams := smithy.InvalidParamsError{Context: "SalesforceCustomKnowledgeArticleTypeConfigurationList"} 1482 for i := range v { 1483 if err := validateSalesforceCustomKnowledgeArticleTypeConfiguration(&v[i]); err != nil { 1484 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1485 } 1486 } 1487 if invalidParams.Len() > 0 { 1488 return invalidParams 1489 } else { 1490 return nil 1491 } 1492} 1493 1494func validateSalesforceKnowledgeArticleConfiguration(v *types.SalesforceKnowledgeArticleConfiguration) error { 1495 if v == nil { 1496 return nil 1497 } 1498 invalidParams := smithy.InvalidParamsError{Context: "SalesforceKnowledgeArticleConfiguration"} 1499 if v.IncludedStates == nil { 1500 invalidParams.Add(smithy.NewErrParamRequired("IncludedStates")) 1501 } 1502 if v.StandardKnowledgeArticleTypeConfiguration != nil { 1503 if err := validateSalesforceStandardKnowledgeArticleTypeConfiguration(v.StandardKnowledgeArticleTypeConfiguration); err != nil { 1504 invalidParams.AddNested("StandardKnowledgeArticleTypeConfiguration", err.(smithy.InvalidParamsError)) 1505 } 1506 } 1507 if v.CustomKnowledgeArticleTypeConfigurations != nil { 1508 if err := validateSalesforceCustomKnowledgeArticleTypeConfigurationList(v.CustomKnowledgeArticleTypeConfigurations); err != nil { 1509 invalidParams.AddNested("CustomKnowledgeArticleTypeConfigurations", err.(smithy.InvalidParamsError)) 1510 } 1511 } 1512 if invalidParams.Len() > 0 { 1513 return invalidParams 1514 } else { 1515 return nil 1516 } 1517} 1518 1519func validateSalesforceStandardKnowledgeArticleTypeConfiguration(v *types.SalesforceStandardKnowledgeArticleTypeConfiguration) error { 1520 if v == nil { 1521 return nil 1522 } 1523 invalidParams := smithy.InvalidParamsError{Context: "SalesforceStandardKnowledgeArticleTypeConfiguration"} 1524 if v.DocumentDataFieldName == nil { 1525 invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName")) 1526 } 1527 if v.FieldMappings != nil { 1528 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1529 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1530 } 1531 } 1532 if invalidParams.Len() > 0 { 1533 return invalidParams 1534 } else { 1535 return nil 1536 } 1537} 1538 1539func validateSalesforceStandardObjectAttachmentConfiguration(v *types.SalesforceStandardObjectAttachmentConfiguration) error { 1540 if v == nil { 1541 return nil 1542 } 1543 invalidParams := smithy.InvalidParamsError{Context: "SalesforceStandardObjectAttachmentConfiguration"} 1544 if v.FieldMappings != nil { 1545 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1546 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1547 } 1548 } 1549 if invalidParams.Len() > 0 { 1550 return invalidParams 1551 } else { 1552 return nil 1553 } 1554} 1555 1556func validateSalesforceStandardObjectConfiguration(v *types.SalesforceStandardObjectConfiguration) error { 1557 if v == nil { 1558 return nil 1559 } 1560 invalidParams := smithy.InvalidParamsError{Context: "SalesforceStandardObjectConfiguration"} 1561 if len(v.Name) == 0 { 1562 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1563 } 1564 if v.DocumentDataFieldName == nil { 1565 invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName")) 1566 } 1567 if v.FieldMappings != nil { 1568 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1569 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1570 } 1571 } 1572 if invalidParams.Len() > 0 { 1573 return invalidParams 1574 } else { 1575 return nil 1576 } 1577} 1578 1579func validateSalesforceStandardObjectConfigurationList(v []types.SalesforceStandardObjectConfiguration) error { 1580 if v == nil { 1581 return nil 1582 } 1583 invalidParams := smithy.InvalidParamsError{Context: "SalesforceStandardObjectConfigurationList"} 1584 for i := range v { 1585 if err := validateSalesforceStandardObjectConfiguration(&v[i]); err != nil { 1586 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1587 } 1588 } 1589 if invalidParams.Len() > 0 { 1590 return invalidParams 1591 } else { 1592 return nil 1593 } 1594} 1595 1596func validateServiceNowConfiguration(v *types.ServiceNowConfiguration) error { 1597 if v == nil { 1598 return nil 1599 } 1600 invalidParams := smithy.InvalidParamsError{Context: "ServiceNowConfiguration"} 1601 if v.HostUrl == nil { 1602 invalidParams.Add(smithy.NewErrParamRequired("HostUrl")) 1603 } 1604 if v.SecretArn == nil { 1605 invalidParams.Add(smithy.NewErrParamRequired("SecretArn")) 1606 } 1607 if len(v.ServiceNowBuildVersion) == 0 { 1608 invalidParams.Add(smithy.NewErrParamRequired("ServiceNowBuildVersion")) 1609 } 1610 if v.KnowledgeArticleConfiguration != nil { 1611 if err := validateServiceNowKnowledgeArticleConfiguration(v.KnowledgeArticleConfiguration); err != nil { 1612 invalidParams.AddNested("KnowledgeArticleConfiguration", err.(smithy.InvalidParamsError)) 1613 } 1614 } 1615 if v.ServiceCatalogConfiguration != nil { 1616 if err := validateServiceNowServiceCatalogConfiguration(v.ServiceCatalogConfiguration); err != nil { 1617 invalidParams.AddNested("ServiceCatalogConfiguration", err.(smithy.InvalidParamsError)) 1618 } 1619 } 1620 if invalidParams.Len() > 0 { 1621 return invalidParams 1622 } else { 1623 return nil 1624 } 1625} 1626 1627func validateServiceNowKnowledgeArticleConfiguration(v *types.ServiceNowKnowledgeArticleConfiguration) error { 1628 if v == nil { 1629 return nil 1630 } 1631 invalidParams := smithy.InvalidParamsError{Context: "ServiceNowKnowledgeArticleConfiguration"} 1632 if v.DocumentDataFieldName == nil { 1633 invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName")) 1634 } 1635 if v.FieldMappings != nil { 1636 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1637 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1638 } 1639 } 1640 if invalidParams.Len() > 0 { 1641 return invalidParams 1642 } else { 1643 return nil 1644 } 1645} 1646 1647func validateServiceNowServiceCatalogConfiguration(v *types.ServiceNowServiceCatalogConfiguration) error { 1648 if v == nil { 1649 return nil 1650 } 1651 invalidParams := smithy.InvalidParamsError{Context: "ServiceNowServiceCatalogConfiguration"} 1652 if v.DocumentDataFieldName == nil { 1653 invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName")) 1654 } 1655 if v.FieldMappings != nil { 1656 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1657 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1658 } 1659 } 1660 if invalidParams.Len() > 0 { 1661 return invalidParams 1662 } else { 1663 return nil 1664 } 1665} 1666 1667func validateSharePointConfiguration(v *types.SharePointConfiguration) error { 1668 if v == nil { 1669 return nil 1670 } 1671 invalidParams := smithy.InvalidParamsError{Context: "SharePointConfiguration"} 1672 if len(v.SharePointVersion) == 0 { 1673 invalidParams.Add(smithy.NewErrParamRequired("SharePointVersion")) 1674 } 1675 if v.Urls == nil { 1676 invalidParams.Add(smithy.NewErrParamRequired("Urls")) 1677 } 1678 if v.SecretArn == nil { 1679 invalidParams.Add(smithy.NewErrParamRequired("SecretArn")) 1680 } 1681 if v.VpcConfiguration != nil { 1682 if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil { 1683 invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError)) 1684 } 1685 } 1686 if v.FieldMappings != nil { 1687 if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil { 1688 invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError)) 1689 } 1690 } 1691 if invalidParams.Len() > 0 { 1692 return invalidParams 1693 } else { 1694 return nil 1695 } 1696} 1697 1698func validateSortingConfiguration(v *types.SortingConfiguration) error { 1699 if v == nil { 1700 return nil 1701 } 1702 invalidParams := smithy.InvalidParamsError{Context: "SortingConfiguration"} 1703 if v.DocumentAttributeKey == nil { 1704 invalidParams.Add(smithy.NewErrParamRequired("DocumentAttributeKey")) 1705 } 1706 if len(v.SortOrder) == 0 { 1707 invalidParams.Add(smithy.NewErrParamRequired("SortOrder")) 1708 } 1709 if invalidParams.Len() > 0 { 1710 return invalidParams 1711 } else { 1712 return nil 1713 } 1714} 1715 1716func validateTag(v *types.Tag) error { 1717 if v == nil { 1718 return nil 1719 } 1720 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1721 if v.Key == nil { 1722 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1723 } 1724 if v.Value == nil { 1725 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1726 } 1727 if invalidParams.Len() > 0 { 1728 return invalidParams 1729 } else { 1730 return nil 1731 } 1732} 1733 1734func validateTagList(v []types.Tag) error { 1735 if v == nil { 1736 return nil 1737 } 1738 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1739 for i := range v { 1740 if err := validateTag(&v[i]); err != nil { 1741 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1742 } 1743 } 1744 if invalidParams.Len() > 0 { 1745 return invalidParams 1746 } else { 1747 return nil 1748 } 1749} 1750 1751func validateUserTokenConfiguration(v *types.UserTokenConfiguration) error { 1752 if v == nil { 1753 return nil 1754 } 1755 invalidParams := smithy.InvalidParamsError{Context: "UserTokenConfiguration"} 1756 if v.JwtTokenTypeConfiguration != nil { 1757 if err := validateJwtTokenTypeConfiguration(v.JwtTokenTypeConfiguration); err != nil { 1758 invalidParams.AddNested("JwtTokenTypeConfiguration", err.(smithy.InvalidParamsError)) 1759 } 1760 } 1761 if v.JsonTokenTypeConfiguration != nil { 1762 if err := validateJsonTokenTypeConfiguration(v.JsonTokenTypeConfiguration); err != nil { 1763 invalidParams.AddNested("JsonTokenTypeConfiguration", err.(smithy.InvalidParamsError)) 1764 } 1765 } 1766 if invalidParams.Len() > 0 { 1767 return invalidParams 1768 } else { 1769 return nil 1770 } 1771} 1772 1773func validateUserTokenConfigurationList(v []types.UserTokenConfiguration) error { 1774 if v == nil { 1775 return nil 1776 } 1777 invalidParams := smithy.InvalidParamsError{Context: "UserTokenConfigurationList"} 1778 for i := range v { 1779 if err := validateUserTokenConfiguration(&v[i]); err != nil { 1780 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1781 } 1782 } 1783 if invalidParams.Len() > 0 { 1784 return invalidParams 1785 } else { 1786 return nil 1787 } 1788} 1789 1790func validateOpBatchDeleteDocumentInput(v *BatchDeleteDocumentInput) error { 1791 if v == nil { 1792 return nil 1793 } 1794 invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteDocumentInput"} 1795 if v.IndexId == nil { 1796 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 1797 } 1798 if v.DocumentIdList == nil { 1799 invalidParams.Add(smithy.NewErrParamRequired("DocumentIdList")) 1800 } 1801 if v.DataSourceSyncJobMetricTarget != nil { 1802 if err := validateDataSourceSyncJobMetricTarget(v.DataSourceSyncJobMetricTarget); err != nil { 1803 invalidParams.AddNested("DataSourceSyncJobMetricTarget", err.(smithy.InvalidParamsError)) 1804 } 1805 } 1806 if invalidParams.Len() > 0 { 1807 return invalidParams 1808 } else { 1809 return nil 1810 } 1811} 1812 1813func validateOpBatchPutDocumentInput(v *BatchPutDocumentInput) error { 1814 if v == nil { 1815 return nil 1816 } 1817 invalidParams := smithy.InvalidParamsError{Context: "BatchPutDocumentInput"} 1818 if v.IndexId == nil { 1819 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 1820 } 1821 if v.Documents == nil { 1822 invalidParams.Add(smithy.NewErrParamRequired("Documents")) 1823 } else if v.Documents != nil { 1824 if err := validateDocumentList(v.Documents); err != nil { 1825 invalidParams.AddNested("Documents", err.(smithy.InvalidParamsError)) 1826 } 1827 } 1828 if invalidParams.Len() > 0 { 1829 return invalidParams 1830 } else { 1831 return nil 1832 } 1833} 1834 1835func validateOpCreateDataSourceInput(v *CreateDataSourceInput) error { 1836 if v == nil { 1837 return nil 1838 } 1839 invalidParams := smithy.InvalidParamsError{Context: "CreateDataSourceInput"} 1840 if v.Name == nil { 1841 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1842 } 1843 if v.IndexId == nil { 1844 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 1845 } 1846 if len(v.Type) == 0 { 1847 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1848 } 1849 if v.Configuration != nil { 1850 if err := validateDataSourceConfiguration(v.Configuration); err != nil { 1851 invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError)) 1852 } 1853 } 1854 if v.Tags != nil { 1855 if err := validateTagList(v.Tags); err != nil { 1856 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1857 } 1858 } 1859 if invalidParams.Len() > 0 { 1860 return invalidParams 1861 } else { 1862 return nil 1863 } 1864} 1865 1866func validateOpCreateFaqInput(v *CreateFaqInput) error { 1867 if v == nil { 1868 return nil 1869 } 1870 invalidParams := smithy.InvalidParamsError{Context: "CreateFaqInput"} 1871 if v.IndexId == nil { 1872 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 1873 } 1874 if v.Name == nil { 1875 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1876 } 1877 if v.S3Path == nil { 1878 invalidParams.Add(smithy.NewErrParamRequired("S3Path")) 1879 } else if v.S3Path != nil { 1880 if err := validateS3Path(v.S3Path); err != nil { 1881 invalidParams.AddNested("S3Path", err.(smithy.InvalidParamsError)) 1882 } 1883 } 1884 if v.RoleArn == nil { 1885 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1886 } 1887 if v.Tags != nil { 1888 if err := validateTagList(v.Tags); err != nil { 1889 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1890 } 1891 } 1892 if invalidParams.Len() > 0 { 1893 return invalidParams 1894 } else { 1895 return nil 1896 } 1897} 1898 1899func validateOpCreateIndexInput(v *CreateIndexInput) error { 1900 if v == nil { 1901 return nil 1902 } 1903 invalidParams := smithy.InvalidParamsError{Context: "CreateIndexInput"} 1904 if v.Name == nil { 1905 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1906 } 1907 if v.RoleArn == nil { 1908 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1909 } 1910 if v.Tags != nil { 1911 if err := validateTagList(v.Tags); err != nil { 1912 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1913 } 1914 } 1915 if v.UserTokenConfigurations != nil { 1916 if err := validateUserTokenConfigurationList(v.UserTokenConfigurations); err != nil { 1917 invalidParams.AddNested("UserTokenConfigurations", err.(smithy.InvalidParamsError)) 1918 } 1919 } 1920 if invalidParams.Len() > 0 { 1921 return invalidParams 1922 } else { 1923 return nil 1924 } 1925} 1926 1927func validateOpCreateThesaurusInput(v *CreateThesaurusInput) error { 1928 if v == nil { 1929 return nil 1930 } 1931 invalidParams := smithy.InvalidParamsError{Context: "CreateThesaurusInput"} 1932 if v.IndexId == nil { 1933 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 1934 } 1935 if v.Name == nil { 1936 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1937 } 1938 if v.RoleArn == nil { 1939 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1940 } 1941 if v.Tags != nil { 1942 if err := validateTagList(v.Tags); err != nil { 1943 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1944 } 1945 } 1946 if v.SourceS3Path == nil { 1947 invalidParams.Add(smithy.NewErrParamRequired("SourceS3Path")) 1948 } else if v.SourceS3Path != nil { 1949 if err := validateS3Path(v.SourceS3Path); err != nil { 1950 invalidParams.AddNested("SourceS3Path", err.(smithy.InvalidParamsError)) 1951 } 1952 } 1953 if invalidParams.Len() > 0 { 1954 return invalidParams 1955 } else { 1956 return nil 1957 } 1958} 1959 1960func validateOpDeleteDataSourceInput(v *DeleteDataSourceInput) error { 1961 if v == nil { 1962 return nil 1963 } 1964 invalidParams := smithy.InvalidParamsError{Context: "DeleteDataSourceInput"} 1965 if v.Id == nil { 1966 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1967 } 1968 if v.IndexId == nil { 1969 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 1970 } 1971 if invalidParams.Len() > 0 { 1972 return invalidParams 1973 } else { 1974 return nil 1975 } 1976} 1977 1978func validateOpDeleteFaqInput(v *DeleteFaqInput) error { 1979 if v == nil { 1980 return nil 1981 } 1982 invalidParams := smithy.InvalidParamsError{Context: "DeleteFaqInput"} 1983 if v.Id == nil { 1984 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1985 } 1986 if v.IndexId == nil { 1987 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 1988 } 1989 if invalidParams.Len() > 0 { 1990 return invalidParams 1991 } else { 1992 return nil 1993 } 1994} 1995 1996func validateOpDeleteIndexInput(v *DeleteIndexInput) error { 1997 if v == nil { 1998 return nil 1999 } 2000 invalidParams := smithy.InvalidParamsError{Context: "DeleteIndexInput"} 2001 if v.Id == nil { 2002 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2003 } 2004 if invalidParams.Len() > 0 { 2005 return invalidParams 2006 } else { 2007 return nil 2008 } 2009} 2010 2011func validateOpDeleteThesaurusInput(v *DeleteThesaurusInput) error { 2012 if v == nil { 2013 return nil 2014 } 2015 invalidParams := smithy.InvalidParamsError{Context: "DeleteThesaurusInput"} 2016 if v.Id == nil { 2017 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2018 } 2019 if v.IndexId == nil { 2020 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2021 } 2022 if invalidParams.Len() > 0 { 2023 return invalidParams 2024 } else { 2025 return nil 2026 } 2027} 2028 2029func validateOpDescribeDataSourceInput(v *DescribeDataSourceInput) error { 2030 if v == nil { 2031 return nil 2032 } 2033 invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSourceInput"} 2034 if v.Id == nil { 2035 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2036 } 2037 if v.IndexId == nil { 2038 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2039 } 2040 if invalidParams.Len() > 0 { 2041 return invalidParams 2042 } else { 2043 return nil 2044 } 2045} 2046 2047func validateOpDescribeFaqInput(v *DescribeFaqInput) error { 2048 if v == nil { 2049 return nil 2050 } 2051 invalidParams := smithy.InvalidParamsError{Context: "DescribeFaqInput"} 2052 if v.Id == nil { 2053 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2054 } 2055 if v.IndexId == nil { 2056 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2057 } 2058 if invalidParams.Len() > 0 { 2059 return invalidParams 2060 } else { 2061 return nil 2062 } 2063} 2064 2065func validateOpDescribeIndexInput(v *DescribeIndexInput) error { 2066 if v == nil { 2067 return nil 2068 } 2069 invalidParams := smithy.InvalidParamsError{Context: "DescribeIndexInput"} 2070 if v.Id == nil { 2071 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2072 } 2073 if invalidParams.Len() > 0 { 2074 return invalidParams 2075 } else { 2076 return nil 2077 } 2078} 2079 2080func validateOpDescribeThesaurusInput(v *DescribeThesaurusInput) error { 2081 if v == nil { 2082 return nil 2083 } 2084 invalidParams := smithy.InvalidParamsError{Context: "DescribeThesaurusInput"} 2085 if v.Id == nil { 2086 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2087 } 2088 if v.IndexId == nil { 2089 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2090 } 2091 if invalidParams.Len() > 0 { 2092 return invalidParams 2093 } else { 2094 return nil 2095 } 2096} 2097 2098func validateOpListDataSourcesInput(v *ListDataSourcesInput) error { 2099 if v == nil { 2100 return nil 2101 } 2102 invalidParams := smithy.InvalidParamsError{Context: "ListDataSourcesInput"} 2103 if v.IndexId == nil { 2104 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2105 } 2106 if invalidParams.Len() > 0 { 2107 return invalidParams 2108 } else { 2109 return nil 2110 } 2111} 2112 2113func validateOpListDataSourceSyncJobsInput(v *ListDataSourceSyncJobsInput) error { 2114 if v == nil { 2115 return nil 2116 } 2117 invalidParams := smithy.InvalidParamsError{Context: "ListDataSourceSyncJobsInput"} 2118 if v.Id == nil { 2119 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2120 } 2121 if v.IndexId == nil { 2122 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2123 } 2124 if invalidParams.Len() > 0 { 2125 return invalidParams 2126 } else { 2127 return nil 2128 } 2129} 2130 2131func validateOpListFaqsInput(v *ListFaqsInput) error { 2132 if v == nil { 2133 return nil 2134 } 2135 invalidParams := smithy.InvalidParamsError{Context: "ListFaqsInput"} 2136 if v.IndexId == nil { 2137 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2138 } 2139 if invalidParams.Len() > 0 { 2140 return invalidParams 2141 } else { 2142 return nil 2143 } 2144} 2145 2146func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 2147 if v == nil { 2148 return nil 2149 } 2150 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 2151 if v.ResourceARN == nil { 2152 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 2153 } 2154 if invalidParams.Len() > 0 { 2155 return invalidParams 2156 } else { 2157 return nil 2158 } 2159} 2160 2161func validateOpListThesauriInput(v *ListThesauriInput) error { 2162 if v == nil { 2163 return nil 2164 } 2165 invalidParams := smithy.InvalidParamsError{Context: "ListThesauriInput"} 2166 if v.IndexId == nil { 2167 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2168 } 2169 if invalidParams.Len() > 0 { 2170 return invalidParams 2171 } else { 2172 return nil 2173 } 2174} 2175 2176func validateOpQueryInput(v *QueryInput) error { 2177 if v == nil { 2178 return nil 2179 } 2180 invalidParams := smithy.InvalidParamsError{Context: "QueryInput"} 2181 if v.IndexId == nil { 2182 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2183 } 2184 if v.QueryText == nil { 2185 invalidParams.Add(smithy.NewErrParamRequired("QueryText")) 2186 } 2187 if v.AttributeFilter != nil { 2188 if err := validateAttributeFilter(v.AttributeFilter); err != nil { 2189 invalidParams.AddNested("AttributeFilter", err.(smithy.InvalidParamsError)) 2190 } 2191 } 2192 if v.SortingConfiguration != nil { 2193 if err := validateSortingConfiguration(v.SortingConfiguration); err != nil { 2194 invalidParams.AddNested("SortingConfiguration", err.(smithy.InvalidParamsError)) 2195 } 2196 } 2197 if invalidParams.Len() > 0 { 2198 return invalidParams 2199 } else { 2200 return nil 2201 } 2202} 2203 2204func validateOpStartDataSourceSyncJobInput(v *StartDataSourceSyncJobInput) error { 2205 if v == nil { 2206 return nil 2207 } 2208 invalidParams := smithy.InvalidParamsError{Context: "StartDataSourceSyncJobInput"} 2209 if v.Id == nil { 2210 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2211 } 2212 if v.IndexId == nil { 2213 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2214 } 2215 if invalidParams.Len() > 0 { 2216 return invalidParams 2217 } else { 2218 return nil 2219 } 2220} 2221 2222func validateOpStopDataSourceSyncJobInput(v *StopDataSourceSyncJobInput) error { 2223 if v == nil { 2224 return nil 2225 } 2226 invalidParams := smithy.InvalidParamsError{Context: "StopDataSourceSyncJobInput"} 2227 if v.Id == nil { 2228 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2229 } 2230 if v.IndexId == nil { 2231 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2232 } 2233 if invalidParams.Len() > 0 { 2234 return invalidParams 2235 } else { 2236 return nil 2237 } 2238} 2239 2240func validateOpSubmitFeedbackInput(v *SubmitFeedbackInput) error { 2241 if v == nil { 2242 return nil 2243 } 2244 invalidParams := smithy.InvalidParamsError{Context: "SubmitFeedbackInput"} 2245 if v.IndexId == nil { 2246 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2247 } 2248 if v.QueryId == nil { 2249 invalidParams.Add(smithy.NewErrParamRequired("QueryId")) 2250 } 2251 if v.ClickFeedbackItems != nil { 2252 if err := validateClickFeedbackList(v.ClickFeedbackItems); err != nil { 2253 invalidParams.AddNested("ClickFeedbackItems", err.(smithy.InvalidParamsError)) 2254 } 2255 } 2256 if v.RelevanceFeedbackItems != nil { 2257 if err := validateRelevanceFeedbackList(v.RelevanceFeedbackItems); err != nil { 2258 invalidParams.AddNested("RelevanceFeedbackItems", err.(smithy.InvalidParamsError)) 2259 } 2260 } 2261 if invalidParams.Len() > 0 { 2262 return invalidParams 2263 } else { 2264 return nil 2265 } 2266} 2267 2268func validateOpTagResourceInput(v *TagResourceInput) error { 2269 if v == nil { 2270 return nil 2271 } 2272 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2273 if v.ResourceARN == nil { 2274 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 2275 } 2276 if v.Tags == nil { 2277 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2278 } else if v.Tags != nil { 2279 if err := validateTagList(v.Tags); err != nil { 2280 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2281 } 2282 } 2283 if invalidParams.Len() > 0 { 2284 return invalidParams 2285 } else { 2286 return nil 2287 } 2288} 2289 2290func validateOpUntagResourceInput(v *UntagResourceInput) error { 2291 if v == nil { 2292 return nil 2293 } 2294 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2295 if v.ResourceARN == nil { 2296 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 2297 } 2298 if v.TagKeys == nil { 2299 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2300 } 2301 if invalidParams.Len() > 0 { 2302 return invalidParams 2303 } else { 2304 return nil 2305 } 2306} 2307 2308func validateOpUpdateDataSourceInput(v *UpdateDataSourceInput) error { 2309 if v == nil { 2310 return nil 2311 } 2312 invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSourceInput"} 2313 if v.Id == nil { 2314 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2315 } 2316 if v.IndexId == nil { 2317 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2318 } 2319 if v.Configuration != nil { 2320 if err := validateDataSourceConfiguration(v.Configuration); err != nil { 2321 invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError)) 2322 } 2323 } 2324 if invalidParams.Len() > 0 { 2325 return invalidParams 2326 } else { 2327 return nil 2328 } 2329} 2330 2331func validateOpUpdateIndexInput(v *UpdateIndexInput) error { 2332 if v == nil { 2333 return nil 2334 } 2335 invalidParams := smithy.InvalidParamsError{Context: "UpdateIndexInput"} 2336 if v.Id == nil { 2337 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2338 } 2339 if v.DocumentMetadataConfigurationUpdates != nil { 2340 if err := validateDocumentMetadataConfigurationList(v.DocumentMetadataConfigurationUpdates); err != nil { 2341 invalidParams.AddNested("DocumentMetadataConfigurationUpdates", err.(smithy.InvalidParamsError)) 2342 } 2343 } 2344 if v.CapacityUnits != nil { 2345 if err := validateCapacityUnitsConfiguration(v.CapacityUnits); err != nil { 2346 invalidParams.AddNested("CapacityUnits", err.(smithy.InvalidParamsError)) 2347 } 2348 } 2349 if v.UserTokenConfigurations != nil { 2350 if err := validateUserTokenConfigurationList(v.UserTokenConfigurations); err != nil { 2351 invalidParams.AddNested("UserTokenConfigurations", err.(smithy.InvalidParamsError)) 2352 } 2353 } 2354 if invalidParams.Len() > 0 { 2355 return invalidParams 2356 } else { 2357 return nil 2358 } 2359} 2360 2361func validateOpUpdateThesaurusInput(v *UpdateThesaurusInput) error { 2362 if v == nil { 2363 return nil 2364 } 2365 invalidParams := smithy.InvalidParamsError{Context: "UpdateThesaurusInput"} 2366 if v.Id == nil { 2367 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2368 } 2369 if v.IndexId == nil { 2370 invalidParams.Add(smithy.NewErrParamRequired("IndexId")) 2371 } 2372 if v.SourceS3Path != nil { 2373 if err := validateS3Path(v.SourceS3Path); err != nil { 2374 invalidParams.AddNested("SourceS3Path", err.(smithy.InvalidParamsError)) 2375 } 2376 } 2377 if invalidParams.Len() > 0 { 2378 return invalidParams 2379 } else { 2380 return nil 2381 } 2382} 2383