1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package schemas 4 5import ( 6 "context" 7 "fmt" 8 smithy "github.com/aws/smithy-go" 9 "github.com/aws/smithy-go/middleware" 10) 11 12type validateOpCreateDiscoverer struct { 13} 14 15func (*validateOpCreateDiscoverer) ID() string { 16 return "OperationInputValidation" 17} 18 19func (m *validateOpCreateDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 20 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 21) { 22 input, ok := in.Parameters.(*CreateDiscovererInput) 23 if !ok { 24 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 25 } 26 if err := validateOpCreateDiscovererInput(input); err != nil { 27 return out, metadata, err 28 } 29 return next.HandleInitialize(ctx, in) 30} 31 32type validateOpCreateRegistry struct { 33} 34 35func (*validateOpCreateRegistry) ID() string { 36 return "OperationInputValidation" 37} 38 39func (m *validateOpCreateRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 40 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 41) { 42 input, ok := in.Parameters.(*CreateRegistryInput) 43 if !ok { 44 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 45 } 46 if err := validateOpCreateRegistryInput(input); err != nil { 47 return out, metadata, err 48 } 49 return next.HandleInitialize(ctx, in) 50} 51 52type validateOpCreateSchema struct { 53} 54 55func (*validateOpCreateSchema) ID() string { 56 return "OperationInputValidation" 57} 58 59func (m *validateOpCreateSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 60 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 61) { 62 input, ok := in.Parameters.(*CreateSchemaInput) 63 if !ok { 64 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 65 } 66 if err := validateOpCreateSchemaInput(input); err != nil { 67 return out, metadata, err 68 } 69 return next.HandleInitialize(ctx, in) 70} 71 72type validateOpDeleteDiscoverer struct { 73} 74 75func (*validateOpDeleteDiscoverer) ID() string { 76 return "OperationInputValidation" 77} 78 79func (m *validateOpDeleteDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 80 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 81) { 82 input, ok := in.Parameters.(*DeleteDiscovererInput) 83 if !ok { 84 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 85 } 86 if err := validateOpDeleteDiscovererInput(input); err != nil { 87 return out, metadata, err 88 } 89 return next.HandleInitialize(ctx, in) 90} 91 92type validateOpDeleteRegistry struct { 93} 94 95func (*validateOpDeleteRegistry) ID() string { 96 return "OperationInputValidation" 97} 98 99func (m *validateOpDeleteRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 100 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 101) { 102 input, ok := in.Parameters.(*DeleteRegistryInput) 103 if !ok { 104 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 105 } 106 if err := validateOpDeleteRegistryInput(input); err != nil { 107 return out, metadata, err 108 } 109 return next.HandleInitialize(ctx, in) 110} 111 112type validateOpDeleteSchema struct { 113} 114 115func (*validateOpDeleteSchema) ID() string { 116 return "OperationInputValidation" 117} 118 119func (m *validateOpDeleteSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 120 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 121) { 122 input, ok := in.Parameters.(*DeleteSchemaInput) 123 if !ok { 124 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 125 } 126 if err := validateOpDeleteSchemaInput(input); err != nil { 127 return out, metadata, err 128 } 129 return next.HandleInitialize(ctx, in) 130} 131 132type validateOpDeleteSchemaVersion struct { 133} 134 135func (*validateOpDeleteSchemaVersion) ID() string { 136 return "OperationInputValidation" 137} 138 139func (m *validateOpDeleteSchemaVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 140 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 141) { 142 input, ok := in.Parameters.(*DeleteSchemaVersionInput) 143 if !ok { 144 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 145 } 146 if err := validateOpDeleteSchemaVersionInput(input); err != nil { 147 return out, metadata, err 148 } 149 return next.HandleInitialize(ctx, in) 150} 151 152type validateOpDescribeCodeBinding struct { 153} 154 155func (*validateOpDescribeCodeBinding) ID() string { 156 return "OperationInputValidation" 157} 158 159func (m *validateOpDescribeCodeBinding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 160 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 161) { 162 input, ok := in.Parameters.(*DescribeCodeBindingInput) 163 if !ok { 164 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 165 } 166 if err := validateOpDescribeCodeBindingInput(input); err != nil { 167 return out, metadata, err 168 } 169 return next.HandleInitialize(ctx, in) 170} 171 172type validateOpDescribeDiscoverer struct { 173} 174 175func (*validateOpDescribeDiscoverer) ID() string { 176 return "OperationInputValidation" 177} 178 179func (m *validateOpDescribeDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 180 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 181) { 182 input, ok := in.Parameters.(*DescribeDiscovererInput) 183 if !ok { 184 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 185 } 186 if err := validateOpDescribeDiscovererInput(input); err != nil { 187 return out, metadata, err 188 } 189 return next.HandleInitialize(ctx, in) 190} 191 192type validateOpDescribeRegistry struct { 193} 194 195func (*validateOpDescribeRegistry) ID() string { 196 return "OperationInputValidation" 197} 198 199func (m *validateOpDescribeRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 200 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 201) { 202 input, ok := in.Parameters.(*DescribeRegistryInput) 203 if !ok { 204 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 205 } 206 if err := validateOpDescribeRegistryInput(input); err != nil { 207 return out, metadata, err 208 } 209 return next.HandleInitialize(ctx, in) 210} 211 212type validateOpDescribeSchema struct { 213} 214 215func (*validateOpDescribeSchema) ID() string { 216 return "OperationInputValidation" 217} 218 219func (m *validateOpDescribeSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 220 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 221) { 222 input, ok := in.Parameters.(*DescribeSchemaInput) 223 if !ok { 224 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 225 } 226 if err := validateOpDescribeSchemaInput(input); err != nil { 227 return out, metadata, err 228 } 229 return next.HandleInitialize(ctx, in) 230} 231 232type validateOpExportSchema struct { 233} 234 235func (*validateOpExportSchema) ID() string { 236 return "OperationInputValidation" 237} 238 239func (m *validateOpExportSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 240 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 241) { 242 input, ok := in.Parameters.(*ExportSchemaInput) 243 if !ok { 244 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 245 } 246 if err := validateOpExportSchemaInput(input); err != nil { 247 return out, metadata, err 248 } 249 return next.HandleInitialize(ctx, in) 250} 251 252type validateOpGetCodeBindingSource struct { 253} 254 255func (*validateOpGetCodeBindingSource) ID() string { 256 return "OperationInputValidation" 257} 258 259func (m *validateOpGetCodeBindingSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 260 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 261) { 262 input, ok := in.Parameters.(*GetCodeBindingSourceInput) 263 if !ok { 264 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 265 } 266 if err := validateOpGetCodeBindingSourceInput(input); err != nil { 267 return out, metadata, err 268 } 269 return next.HandleInitialize(ctx, in) 270} 271 272type validateOpGetDiscoveredSchema struct { 273} 274 275func (*validateOpGetDiscoveredSchema) ID() string { 276 return "OperationInputValidation" 277} 278 279func (m *validateOpGetDiscoveredSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 280 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 281) { 282 input, ok := in.Parameters.(*GetDiscoveredSchemaInput) 283 if !ok { 284 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 285 } 286 if err := validateOpGetDiscoveredSchemaInput(input); err != nil { 287 return out, metadata, err 288 } 289 return next.HandleInitialize(ctx, in) 290} 291 292type validateOpListSchemas struct { 293} 294 295func (*validateOpListSchemas) ID() string { 296 return "OperationInputValidation" 297} 298 299func (m *validateOpListSchemas) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 300 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 301) { 302 input, ok := in.Parameters.(*ListSchemasInput) 303 if !ok { 304 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 305 } 306 if err := validateOpListSchemasInput(input); err != nil { 307 return out, metadata, err 308 } 309 return next.HandleInitialize(ctx, in) 310} 311 312type validateOpListSchemaVersions struct { 313} 314 315func (*validateOpListSchemaVersions) ID() string { 316 return "OperationInputValidation" 317} 318 319func (m *validateOpListSchemaVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 320 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 321) { 322 input, ok := in.Parameters.(*ListSchemaVersionsInput) 323 if !ok { 324 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 325 } 326 if err := validateOpListSchemaVersionsInput(input); err != nil { 327 return out, metadata, err 328 } 329 return next.HandleInitialize(ctx, in) 330} 331 332type validateOpListTagsForResource struct { 333} 334 335func (*validateOpListTagsForResource) ID() string { 336 return "OperationInputValidation" 337} 338 339func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 340 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 341) { 342 input, ok := in.Parameters.(*ListTagsForResourceInput) 343 if !ok { 344 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 345 } 346 if err := validateOpListTagsForResourceInput(input); err != nil { 347 return out, metadata, err 348 } 349 return next.HandleInitialize(ctx, in) 350} 351 352type validateOpPutCodeBinding struct { 353} 354 355func (*validateOpPutCodeBinding) ID() string { 356 return "OperationInputValidation" 357} 358 359func (m *validateOpPutCodeBinding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 360 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 361) { 362 input, ok := in.Parameters.(*PutCodeBindingInput) 363 if !ok { 364 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 365 } 366 if err := validateOpPutCodeBindingInput(input); err != nil { 367 return out, metadata, err 368 } 369 return next.HandleInitialize(ctx, in) 370} 371 372type validateOpPutResourcePolicy struct { 373} 374 375func (*validateOpPutResourcePolicy) ID() string { 376 return "OperationInputValidation" 377} 378 379func (m *validateOpPutResourcePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 380 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 381) { 382 input, ok := in.Parameters.(*PutResourcePolicyInput) 383 if !ok { 384 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 385 } 386 if err := validateOpPutResourcePolicyInput(input); err != nil { 387 return out, metadata, err 388 } 389 return next.HandleInitialize(ctx, in) 390} 391 392type validateOpSearchSchemas struct { 393} 394 395func (*validateOpSearchSchemas) ID() string { 396 return "OperationInputValidation" 397} 398 399func (m *validateOpSearchSchemas) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 400 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 401) { 402 input, ok := in.Parameters.(*SearchSchemasInput) 403 if !ok { 404 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 405 } 406 if err := validateOpSearchSchemasInput(input); err != nil { 407 return out, metadata, err 408 } 409 return next.HandleInitialize(ctx, in) 410} 411 412type validateOpStartDiscoverer struct { 413} 414 415func (*validateOpStartDiscoverer) ID() string { 416 return "OperationInputValidation" 417} 418 419func (m *validateOpStartDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 420 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 421) { 422 input, ok := in.Parameters.(*StartDiscovererInput) 423 if !ok { 424 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 425 } 426 if err := validateOpStartDiscovererInput(input); err != nil { 427 return out, metadata, err 428 } 429 return next.HandleInitialize(ctx, in) 430} 431 432type validateOpStopDiscoverer struct { 433} 434 435func (*validateOpStopDiscoverer) ID() string { 436 return "OperationInputValidation" 437} 438 439func (m *validateOpStopDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 440 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 441) { 442 input, ok := in.Parameters.(*StopDiscovererInput) 443 if !ok { 444 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 445 } 446 if err := validateOpStopDiscovererInput(input); err != nil { 447 return out, metadata, err 448 } 449 return next.HandleInitialize(ctx, in) 450} 451 452type validateOpTagResource struct { 453} 454 455func (*validateOpTagResource) ID() string { 456 return "OperationInputValidation" 457} 458 459func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 460 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 461) { 462 input, ok := in.Parameters.(*TagResourceInput) 463 if !ok { 464 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 465 } 466 if err := validateOpTagResourceInput(input); err != nil { 467 return out, metadata, err 468 } 469 return next.HandleInitialize(ctx, in) 470} 471 472type validateOpUntagResource struct { 473} 474 475func (*validateOpUntagResource) ID() string { 476 return "OperationInputValidation" 477} 478 479func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 480 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 481) { 482 input, ok := in.Parameters.(*UntagResourceInput) 483 if !ok { 484 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 485 } 486 if err := validateOpUntagResourceInput(input); err != nil { 487 return out, metadata, err 488 } 489 return next.HandleInitialize(ctx, in) 490} 491 492type validateOpUpdateDiscoverer struct { 493} 494 495func (*validateOpUpdateDiscoverer) ID() string { 496 return "OperationInputValidation" 497} 498 499func (m *validateOpUpdateDiscoverer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 500 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 501) { 502 input, ok := in.Parameters.(*UpdateDiscovererInput) 503 if !ok { 504 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 505 } 506 if err := validateOpUpdateDiscovererInput(input); err != nil { 507 return out, metadata, err 508 } 509 return next.HandleInitialize(ctx, in) 510} 511 512type validateOpUpdateRegistry struct { 513} 514 515func (*validateOpUpdateRegistry) ID() string { 516 return "OperationInputValidation" 517} 518 519func (m *validateOpUpdateRegistry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 520 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 521) { 522 input, ok := in.Parameters.(*UpdateRegistryInput) 523 if !ok { 524 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 525 } 526 if err := validateOpUpdateRegistryInput(input); err != nil { 527 return out, metadata, err 528 } 529 return next.HandleInitialize(ctx, in) 530} 531 532type validateOpUpdateSchema struct { 533} 534 535func (*validateOpUpdateSchema) ID() string { 536 return "OperationInputValidation" 537} 538 539func (m *validateOpUpdateSchema) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 540 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 541) { 542 input, ok := in.Parameters.(*UpdateSchemaInput) 543 if !ok { 544 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 545 } 546 if err := validateOpUpdateSchemaInput(input); err != nil { 547 return out, metadata, err 548 } 549 return next.HandleInitialize(ctx, in) 550} 551 552func addOpCreateDiscovererValidationMiddleware(stack *middleware.Stack) error { 553 return stack.Initialize.Add(&validateOpCreateDiscoverer{}, middleware.After) 554} 555 556func addOpCreateRegistryValidationMiddleware(stack *middleware.Stack) error { 557 return stack.Initialize.Add(&validateOpCreateRegistry{}, middleware.After) 558} 559 560func addOpCreateSchemaValidationMiddleware(stack *middleware.Stack) error { 561 return stack.Initialize.Add(&validateOpCreateSchema{}, middleware.After) 562} 563 564func addOpDeleteDiscovererValidationMiddleware(stack *middleware.Stack) error { 565 return stack.Initialize.Add(&validateOpDeleteDiscoverer{}, middleware.After) 566} 567 568func addOpDeleteRegistryValidationMiddleware(stack *middleware.Stack) error { 569 return stack.Initialize.Add(&validateOpDeleteRegistry{}, middleware.After) 570} 571 572func addOpDeleteSchemaValidationMiddleware(stack *middleware.Stack) error { 573 return stack.Initialize.Add(&validateOpDeleteSchema{}, middleware.After) 574} 575 576func addOpDeleteSchemaVersionValidationMiddleware(stack *middleware.Stack) error { 577 return stack.Initialize.Add(&validateOpDeleteSchemaVersion{}, middleware.After) 578} 579 580func addOpDescribeCodeBindingValidationMiddleware(stack *middleware.Stack) error { 581 return stack.Initialize.Add(&validateOpDescribeCodeBinding{}, middleware.After) 582} 583 584func addOpDescribeDiscovererValidationMiddleware(stack *middleware.Stack) error { 585 return stack.Initialize.Add(&validateOpDescribeDiscoverer{}, middleware.After) 586} 587 588func addOpDescribeRegistryValidationMiddleware(stack *middleware.Stack) error { 589 return stack.Initialize.Add(&validateOpDescribeRegistry{}, middleware.After) 590} 591 592func addOpDescribeSchemaValidationMiddleware(stack *middleware.Stack) error { 593 return stack.Initialize.Add(&validateOpDescribeSchema{}, middleware.After) 594} 595 596func addOpExportSchemaValidationMiddleware(stack *middleware.Stack) error { 597 return stack.Initialize.Add(&validateOpExportSchema{}, middleware.After) 598} 599 600func addOpGetCodeBindingSourceValidationMiddleware(stack *middleware.Stack) error { 601 return stack.Initialize.Add(&validateOpGetCodeBindingSource{}, middleware.After) 602} 603 604func addOpGetDiscoveredSchemaValidationMiddleware(stack *middleware.Stack) error { 605 return stack.Initialize.Add(&validateOpGetDiscoveredSchema{}, middleware.After) 606} 607 608func addOpListSchemasValidationMiddleware(stack *middleware.Stack) error { 609 return stack.Initialize.Add(&validateOpListSchemas{}, middleware.After) 610} 611 612func addOpListSchemaVersionsValidationMiddleware(stack *middleware.Stack) error { 613 return stack.Initialize.Add(&validateOpListSchemaVersions{}, middleware.After) 614} 615 616func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 617 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 618} 619 620func addOpPutCodeBindingValidationMiddleware(stack *middleware.Stack) error { 621 return stack.Initialize.Add(&validateOpPutCodeBinding{}, middleware.After) 622} 623 624func addOpPutResourcePolicyValidationMiddleware(stack *middleware.Stack) error { 625 return stack.Initialize.Add(&validateOpPutResourcePolicy{}, middleware.After) 626} 627 628func addOpSearchSchemasValidationMiddleware(stack *middleware.Stack) error { 629 return stack.Initialize.Add(&validateOpSearchSchemas{}, middleware.After) 630} 631 632func addOpStartDiscovererValidationMiddleware(stack *middleware.Stack) error { 633 return stack.Initialize.Add(&validateOpStartDiscoverer{}, middleware.After) 634} 635 636func addOpStopDiscovererValidationMiddleware(stack *middleware.Stack) error { 637 return stack.Initialize.Add(&validateOpStopDiscoverer{}, middleware.After) 638} 639 640func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 641 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 642} 643 644func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 645 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 646} 647 648func addOpUpdateDiscovererValidationMiddleware(stack *middleware.Stack) error { 649 return stack.Initialize.Add(&validateOpUpdateDiscoverer{}, middleware.After) 650} 651 652func addOpUpdateRegistryValidationMiddleware(stack *middleware.Stack) error { 653 return stack.Initialize.Add(&validateOpUpdateRegistry{}, middleware.After) 654} 655 656func addOpUpdateSchemaValidationMiddleware(stack *middleware.Stack) error { 657 return stack.Initialize.Add(&validateOpUpdateSchema{}, middleware.After) 658} 659 660func validateOpCreateDiscovererInput(v *CreateDiscovererInput) error { 661 if v == nil { 662 return nil 663 } 664 invalidParams := smithy.InvalidParamsError{Context: "CreateDiscovererInput"} 665 if v.SourceArn == nil { 666 invalidParams.Add(smithy.NewErrParamRequired("SourceArn")) 667 } 668 if invalidParams.Len() > 0 { 669 return invalidParams 670 } else { 671 return nil 672 } 673} 674 675func validateOpCreateRegistryInput(v *CreateRegistryInput) error { 676 if v == nil { 677 return nil 678 } 679 invalidParams := smithy.InvalidParamsError{Context: "CreateRegistryInput"} 680 if v.RegistryName == nil { 681 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 682 } 683 if invalidParams.Len() > 0 { 684 return invalidParams 685 } else { 686 return nil 687 } 688} 689 690func validateOpCreateSchemaInput(v *CreateSchemaInput) error { 691 if v == nil { 692 return nil 693 } 694 invalidParams := smithy.InvalidParamsError{Context: "CreateSchemaInput"} 695 if v.Content == nil { 696 invalidParams.Add(smithy.NewErrParamRequired("Content")) 697 } 698 if v.RegistryName == nil { 699 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 700 } 701 if v.SchemaName == nil { 702 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 703 } 704 if len(v.Type) == 0 { 705 invalidParams.Add(smithy.NewErrParamRequired("Type")) 706 } 707 if invalidParams.Len() > 0 { 708 return invalidParams 709 } else { 710 return nil 711 } 712} 713 714func validateOpDeleteDiscovererInput(v *DeleteDiscovererInput) error { 715 if v == nil { 716 return nil 717 } 718 invalidParams := smithy.InvalidParamsError{Context: "DeleteDiscovererInput"} 719 if v.DiscovererId == nil { 720 invalidParams.Add(smithy.NewErrParamRequired("DiscovererId")) 721 } 722 if invalidParams.Len() > 0 { 723 return invalidParams 724 } else { 725 return nil 726 } 727} 728 729func validateOpDeleteRegistryInput(v *DeleteRegistryInput) error { 730 if v == nil { 731 return nil 732 } 733 invalidParams := smithy.InvalidParamsError{Context: "DeleteRegistryInput"} 734 if v.RegistryName == nil { 735 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 736 } 737 if invalidParams.Len() > 0 { 738 return invalidParams 739 } else { 740 return nil 741 } 742} 743 744func validateOpDeleteSchemaInput(v *DeleteSchemaInput) error { 745 if v == nil { 746 return nil 747 } 748 invalidParams := smithy.InvalidParamsError{Context: "DeleteSchemaInput"} 749 if v.RegistryName == nil { 750 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 751 } 752 if v.SchemaName == nil { 753 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 754 } 755 if invalidParams.Len() > 0 { 756 return invalidParams 757 } else { 758 return nil 759 } 760} 761 762func validateOpDeleteSchemaVersionInput(v *DeleteSchemaVersionInput) error { 763 if v == nil { 764 return nil 765 } 766 invalidParams := smithy.InvalidParamsError{Context: "DeleteSchemaVersionInput"} 767 if v.RegistryName == nil { 768 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 769 } 770 if v.SchemaName == nil { 771 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 772 } 773 if v.SchemaVersion == nil { 774 invalidParams.Add(smithy.NewErrParamRequired("SchemaVersion")) 775 } 776 if invalidParams.Len() > 0 { 777 return invalidParams 778 } else { 779 return nil 780 } 781} 782 783func validateOpDescribeCodeBindingInput(v *DescribeCodeBindingInput) error { 784 if v == nil { 785 return nil 786 } 787 invalidParams := smithy.InvalidParamsError{Context: "DescribeCodeBindingInput"} 788 if v.Language == nil { 789 invalidParams.Add(smithy.NewErrParamRequired("Language")) 790 } 791 if v.RegistryName == nil { 792 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 793 } 794 if v.SchemaName == nil { 795 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 796 } 797 if invalidParams.Len() > 0 { 798 return invalidParams 799 } else { 800 return nil 801 } 802} 803 804func validateOpDescribeDiscovererInput(v *DescribeDiscovererInput) error { 805 if v == nil { 806 return nil 807 } 808 invalidParams := smithy.InvalidParamsError{Context: "DescribeDiscovererInput"} 809 if v.DiscovererId == nil { 810 invalidParams.Add(smithy.NewErrParamRequired("DiscovererId")) 811 } 812 if invalidParams.Len() > 0 { 813 return invalidParams 814 } else { 815 return nil 816 } 817} 818 819func validateOpDescribeRegistryInput(v *DescribeRegistryInput) error { 820 if v == nil { 821 return nil 822 } 823 invalidParams := smithy.InvalidParamsError{Context: "DescribeRegistryInput"} 824 if v.RegistryName == nil { 825 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 826 } 827 if invalidParams.Len() > 0 { 828 return invalidParams 829 } else { 830 return nil 831 } 832} 833 834func validateOpDescribeSchemaInput(v *DescribeSchemaInput) error { 835 if v == nil { 836 return nil 837 } 838 invalidParams := smithy.InvalidParamsError{Context: "DescribeSchemaInput"} 839 if v.RegistryName == nil { 840 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 841 } 842 if v.SchemaName == nil { 843 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 844 } 845 if invalidParams.Len() > 0 { 846 return invalidParams 847 } else { 848 return nil 849 } 850} 851 852func validateOpExportSchemaInput(v *ExportSchemaInput) error { 853 if v == nil { 854 return nil 855 } 856 invalidParams := smithy.InvalidParamsError{Context: "ExportSchemaInput"} 857 if v.RegistryName == nil { 858 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 859 } 860 if v.SchemaName == nil { 861 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 862 } 863 if v.Type == nil { 864 invalidParams.Add(smithy.NewErrParamRequired("Type")) 865 } 866 if invalidParams.Len() > 0 { 867 return invalidParams 868 } else { 869 return nil 870 } 871} 872 873func validateOpGetCodeBindingSourceInput(v *GetCodeBindingSourceInput) error { 874 if v == nil { 875 return nil 876 } 877 invalidParams := smithy.InvalidParamsError{Context: "GetCodeBindingSourceInput"} 878 if v.Language == nil { 879 invalidParams.Add(smithy.NewErrParamRequired("Language")) 880 } 881 if v.RegistryName == nil { 882 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 883 } 884 if v.SchemaName == nil { 885 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 886 } 887 if invalidParams.Len() > 0 { 888 return invalidParams 889 } else { 890 return nil 891 } 892} 893 894func validateOpGetDiscoveredSchemaInput(v *GetDiscoveredSchemaInput) error { 895 if v == nil { 896 return nil 897 } 898 invalidParams := smithy.InvalidParamsError{Context: "GetDiscoveredSchemaInput"} 899 if v.Events == nil { 900 invalidParams.Add(smithy.NewErrParamRequired("Events")) 901 } 902 if len(v.Type) == 0 { 903 invalidParams.Add(smithy.NewErrParamRequired("Type")) 904 } 905 if invalidParams.Len() > 0 { 906 return invalidParams 907 } else { 908 return nil 909 } 910} 911 912func validateOpListSchemasInput(v *ListSchemasInput) error { 913 if v == nil { 914 return nil 915 } 916 invalidParams := smithy.InvalidParamsError{Context: "ListSchemasInput"} 917 if v.RegistryName == nil { 918 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 919 } 920 if invalidParams.Len() > 0 { 921 return invalidParams 922 } else { 923 return nil 924 } 925} 926 927func validateOpListSchemaVersionsInput(v *ListSchemaVersionsInput) error { 928 if v == nil { 929 return nil 930 } 931 invalidParams := smithy.InvalidParamsError{Context: "ListSchemaVersionsInput"} 932 if v.RegistryName == nil { 933 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 934 } 935 if v.SchemaName == nil { 936 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 937 } 938 if invalidParams.Len() > 0 { 939 return invalidParams 940 } else { 941 return nil 942 } 943} 944 945func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 946 if v == nil { 947 return nil 948 } 949 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 950 if v.ResourceArn == nil { 951 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 952 } 953 if invalidParams.Len() > 0 { 954 return invalidParams 955 } else { 956 return nil 957 } 958} 959 960func validateOpPutCodeBindingInput(v *PutCodeBindingInput) error { 961 if v == nil { 962 return nil 963 } 964 invalidParams := smithy.InvalidParamsError{Context: "PutCodeBindingInput"} 965 if v.Language == nil { 966 invalidParams.Add(smithy.NewErrParamRequired("Language")) 967 } 968 if v.RegistryName == nil { 969 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 970 } 971 if v.SchemaName == nil { 972 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 973 } 974 if invalidParams.Len() > 0 { 975 return invalidParams 976 } else { 977 return nil 978 } 979} 980 981func validateOpPutResourcePolicyInput(v *PutResourcePolicyInput) error { 982 if v == nil { 983 return nil 984 } 985 invalidParams := smithy.InvalidParamsError{Context: "PutResourcePolicyInput"} 986 if v.Policy == nil { 987 invalidParams.Add(smithy.NewErrParamRequired("Policy")) 988 } 989 if invalidParams.Len() > 0 { 990 return invalidParams 991 } else { 992 return nil 993 } 994} 995 996func validateOpSearchSchemasInput(v *SearchSchemasInput) error { 997 if v == nil { 998 return nil 999 } 1000 invalidParams := smithy.InvalidParamsError{Context: "SearchSchemasInput"} 1001 if v.Keywords == nil { 1002 invalidParams.Add(smithy.NewErrParamRequired("Keywords")) 1003 } 1004 if v.RegistryName == nil { 1005 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 1006 } 1007 if invalidParams.Len() > 0 { 1008 return invalidParams 1009 } else { 1010 return nil 1011 } 1012} 1013 1014func validateOpStartDiscovererInput(v *StartDiscovererInput) error { 1015 if v == nil { 1016 return nil 1017 } 1018 invalidParams := smithy.InvalidParamsError{Context: "StartDiscovererInput"} 1019 if v.DiscovererId == nil { 1020 invalidParams.Add(smithy.NewErrParamRequired("DiscovererId")) 1021 } 1022 if invalidParams.Len() > 0 { 1023 return invalidParams 1024 } else { 1025 return nil 1026 } 1027} 1028 1029func validateOpStopDiscovererInput(v *StopDiscovererInput) error { 1030 if v == nil { 1031 return nil 1032 } 1033 invalidParams := smithy.InvalidParamsError{Context: "StopDiscovererInput"} 1034 if v.DiscovererId == nil { 1035 invalidParams.Add(smithy.NewErrParamRequired("DiscovererId")) 1036 } 1037 if invalidParams.Len() > 0 { 1038 return invalidParams 1039 } else { 1040 return nil 1041 } 1042} 1043 1044func validateOpTagResourceInput(v *TagResourceInput) error { 1045 if v == nil { 1046 return nil 1047 } 1048 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1049 if v.ResourceArn == nil { 1050 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1051 } 1052 if v.Tags == nil { 1053 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1054 } 1055 if invalidParams.Len() > 0 { 1056 return invalidParams 1057 } else { 1058 return nil 1059 } 1060} 1061 1062func validateOpUntagResourceInput(v *UntagResourceInput) error { 1063 if v == nil { 1064 return nil 1065 } 1066 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1067 if v.ResourceArn == nil { 1068 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1069 } 1070 if v.TagKeys == nil { 1071 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1072 } 1073 if invalidParams.Len() > 0 { 1074 return invalidParams 1075 } else { 1076 return nil 1077 } 1078} 1079 1080func validateOpUpdateDiscovererInput(v *UpdateDiscovererInput) error { 1081 if v == nil { 1082 return nil 1083 } 1084 invalidParams := smithy.InvalidParamsError{Context: "UpdateDiscovererInput"} 1085 if v.DiscovererId == nil { 1086 invalidParams.Add(smithy.NewErrParamRequired("DiscovererId")) 1087 } 1088 if invalidParams.Len() > 0 { 1089 return invalidParams 1090 } else { 1091 return nil 1092 } 1093} 1094 1095func validateOpUpdateRegistryInput(v *UpdateRegistryInput) error { 1096 if v == nil { 1097 return nil 1098 } 1099 invalidParams := smithy.InvalidParamsError{Context: "UpdateRegistryInput"} 1100 if v.RegistryName == nil { 1101 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 1102 } 1103 if invalidParams.Len() > 0 { 1104 return invalidParams 1105 } else { 1106 return nil 1107 } 1108} 1109 1110func validateOpUpdateSchemaInput(v *UpdateSchemaInput) error { 1111 if v == nil { 1112 return nil 1113 } 1114 invalidParams := smithy.InvalidParamsError{Context: "UpdateSchemaInput"} 1115 if v.RegistryName == nil { 1116 invalidParams.Add(smithy.NewErrParamRequired("RegistryName")) 1117 } 1118 if v.SchemaName == nil { 1119 invalidParams.Add(smithy.NewErrParamRequired("SchemaName")) 1120 } 1121 if invalidParams.Len() > 0 { 1122 return invalidParams 1123 } else { 1124 return nil 1125 } 1126} 1127