1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package iotthingsgraph 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/iotthingsgraph/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAssociateEntityToThing struct { 14} 15 16func (*validateOpAssociateEntityToThing) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAssociateEntityToThing) 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.(*AssociateEntityToThingInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAssociateEntityToThingInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateFlowTemplate struct { 34} 35 36func (*validateOpCreateFlowTemplate) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateFlowTemplate) 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.(*CreateFlowTemplateInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateFlowTemplateInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateSystemInstance struct { 54} 55 56func (*validateOpCreateSystemInstance) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateSystemInstance) 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.(*CreateSystemInstanceInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateSystemInstanceInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateSystemTemplate struct { 74} 75 76func (*validateOpCreateSystemTemplate) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateSystemTemplate) 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.(*CreateSystemTemplateInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateSystemTemplateInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpDeleteFlowTemplate struct { 94} 95 96func (*validateOpDeleteFlowTemplate) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpDeleteFlowTemplate) 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.(*DeleteFlowTemplateInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpDeleteFlowTemplateInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeleteSystemTemplate struct { 114} 115 116func (*validateOpDeleteSystemTemplate) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeleteSystemTemplate) 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.(*DeleteSystemTemplateInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeleteSystemTemplateInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeprecateFlowTemplate struct { 134} 135 136func (*validateOpDeprecateFlowTemplate) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeprecateFlowTemplate) 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.(*DeprecateFlowTemplateInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeprecateFlowTemplateInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeprecateSystemTemplate struct { 154} 155 156func (*validateOpDeprecateSystemTemplate) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeprecateSystemTemplate) 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.(*DeprecateSystemTemplateInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeprecateSystemTemplateInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDissociateEntityFromThing struct { 174} 175 176func (*validateOpDissociateEntityFromThing) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDissociateEntityFromThing) 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.(*DissociateEntityFromThingInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDissociateEntityFromThingInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpGetEntities struct { 194} 195 196func (*validateOpGetEntities) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpGetEntities) 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.(*GetEntitiesInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpGetEntitiesInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpGetFlowTemplate struct { 214} 215 216func (*validateOpGetFlowTemplate) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpGetFlowTemplate) 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.(*GetFlowTemplateInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpGetFlowTemplateInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpGetFlowTemplateRevisions struct { 234} 235 236func (*validateOpGetFlowTemplateRevisions) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpGetFlowTemplateRevisions) 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.(*GetFlowTemplateRevisionsInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpGetFlowTemplateRevisionsInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpGetSystemInstance struct { 254} 255 256func (*validateOpGetSystemInstance) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpGetSystemInstance) 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.(*GetSystemInstanceInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpGetSystemInstanceInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpGetSystemTemplate struct { 274} 275 276func (*validateOpGetSystemTemplate) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpGetSystemTemplate) 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.(*GetSystemTemplateInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpGetSystemTemplateInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpGetSystemTemplateRevisions struct { 294} 295 296func (*validateOpGetSystemTemplateRevisions) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpGetSystemTemplateRevisions) 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.(*GetSystemTemplateRevisionsInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpGetSystemTemplateRevisionsInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpGetUploadStatus struct { 314} 315 316func (*validateOpGetUploadStatus) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpGetUploadStatus) 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.(*GetUploadStatusInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpGetUploadStatusInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpListFlowExecutionMessages struct { 334} 335 336func (*validateOpListFlowExecutionMessages) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpListFlowExecutionMessages) 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.(*ListFlowExecutionMessagesInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpListFlowExecutionMessagesInput(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 validateOpSearchEntities struct { 374} 375 376func (*validateOpSearchEntities) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpSearchEntities) 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.(*SearchEntitiesInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpSearchEntitiesInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpSearchFlowExecutions struct { 394} 395 396func (*validateOpSearchFlowExecutions) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpSearchFlowExecutions) 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.(*SearchFlowExecutionsInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpSearchFlowExecutionsInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpSearchFlowTemplates struct { 414} 415 416func (*validateOpSearchFlowTemplates) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpSearchFlowTemplates) 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.(*SearchFlowTemplatesInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpSearchFlowTemplatesInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpSearchSystemTemplates struct { 434} 435 436func (*validateOpSearchSystemTemplates) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpSearchSystemTemplates) 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.(*SearchSystemTemplatesInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpSearchSystemTemplatesInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpSearchThings struct { 454} 455 456func (*validateOpSearchThings) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpSearchThings) 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.(*SearchThingsInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpSearchThingsInput(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 validateOpUpdateFlowTemplate struct { 514} 515 516func (*validateOpUpdateFlowTemplate) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpUpdateFlowTemplate) 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.(*UpdateFlowTemplateInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpUpdateFlowTemplateInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpUpdateSystemTemplate struct { 534} 535 536func (*validateOpUpdateSystemTemplate) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpUpdateSystemTemplate) 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.(*UpdateSystemTemplateInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpUpdateSystemTemplateInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpUploadEntityDefinitions struct { 554} 555 556func (*validateOpUploadEntityDefinitions) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpUploadEntityDefinitions) 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.(*UploadEntityDefinitionsInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpUploadEntityDefinitionsInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573func addOpAssociateEntityToThingValidationMiddleware(stack *middleware.Stack) error { 574 return stack.Initialize.Add(&validateOpAssociateEntityToThing{}, middleware.After) 575} 576 577func addOpCreateFlowTemplateValidationMiddleware(stack *middleware.Stack) error { 578 return stack.Initialize.Add(&validateOpCreateFlowTemplate{}, middleware.After) 579} 580 581func addOpCreateSystemInstanceValidationMiddleware(stack *middleware.Stack) error { 582 return stack.Initialize.Add(&validateOpCreateSystemInstance{}, middleware.After) 583} 584 585func addOpCreateSystemTemplateValidationMiddleware(stack *middleware.Stack) error { 586 return stack.Initialize.Add(&validateOpCreateSystemTemplate{}, middleware.After) 587} 588 589func addOpDeleteFlowTemplateValidationMiddleware(stack *middleware.Stack) error { 590 return stack.Initialize.Add(&validateOpDeleteFlowTemplate{}, middleware.After) 591} 592 593func addOpDeleteSystemTemplateValidationMiddleware(stack *middleware.Stack) error { 594 return stack.Initialize.Add(&validateOpDeleteSystemTemplate{}, middleware.After) 595} 596 597func addOpDeprecateFlowTemplateValidationMiddleware(stack *middleware.Stack) error { 598 return stack.Initialize.Add(&validateOpDeprecateFlowTemplate{}, middleware.After) 599} 600 601func addOpDeprecateSystemTemplateValidationMiddleware(stack *middleware.Stack) error { 602 return stack.Initialize.Add(&validateOpDeprecateSystemTemplate{}, middleware.After) 603} 604 605func addOpDissociateEntityFromThingValidationMiddleware(stack *middleware.Stack) error { 606 return stack.Initialize.Add(&validateOpDissociateEntityFromThing{}, middleware.After) 607} 608 609func addOpGetEntitiesValidationMiddleware(stack *middleware.Stack) error { 610 return stack.Initialize.Add(&validateOpGetEntities{}, middleware.After) 611} 612 613func addOpGetFlowTemplateValidationMiddleware(stack *middleware.Stack) error { 614 return stack.Initialize.Add(&validateOpGetFlowTemplate{}, middleware.After) 615} 616 617func addOpGetFlowTemplateRevisionsValidationMiddleware(stack *middleware.Stack) error { 618 return stack.Initialize.Add(&validateOpGetFlowTemplateRevisions{}, middleware.After) 619} 620 621func addOpGetSystemInstanceValidationMiddleware(stack *middleware.Stack) error { 622 return stack.Initialize.Add(&validateOpGetSystemInstance{}, middleware.After) 623} 624 625func addOpGetSystemTemplateValidationMiddleware(stack *middleware.Stack) error { 626 return stack.Initialize.Add(&validateOpGetSystemTemplate{}, middleware.After) 627} 628 629func addOpGetSystemTemplateRevisionsValidationMiddleware(stack *middleware.Stack) error { 630 return stack.Initialize.Add(&validateOpGetSystemTemplateRevisions{}, middleware.After) 631} 632 633func addOpGetUploadStatusValidationMiddleware(stack *middleware.Stack) error { 634 return stack.Initialize.Add(&validateOpGetUploadStatus{}, middleware.After) 635} 636 637func addOpListFlowExecutionMessagesValidationMiddleware(stack *middleware.Stack) error { 638 return stack.Initialize.Add(&validateOpListFlowExecutionMessages{}, middleware.After) 639} 640 641func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 642 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 643} 644 645func addOpSearchEntitiesValidationMiddleware(stack *middleware.Stack) error { 646 return stack.Initialize.Add(&validateOpSearchEntities{}, middleware.After) 647} 648 649func addOpSearchFlowExecutionsValidationMiddleware(stack *middleware.Stack) error { 650 return stack.Initialize.Add(&validateOpSearchFlowExecutions{}, middleware.After) 651} 652 653func addOpSearchFlowTemplatesValidationMiddleware(stack *middleware.Stack) error { 654 return stack.Initialize.Add(&validateOpSearchFlowTemplates{}, middleware.After) 655} 656 657func addOpSearchSystemTemplatesValidationMiddleware(stack *middleware.Stack) error { 658 return stack.Initialize.Add(&validateOpSearchSystemTemplates{}, middleware.After) 659} 660 661func addOpSearchThingsValidationMiddleware(stack *middleware.Stack) error { 662 return stack.Initialize.Add(&validateOpSearchThings{}, 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 addOpUpdateFlowTemplateValidationMiddleware(stack *middleware.Stack) error { 674 return stack.Initialize.Add(&validateOpUpdateFlowTemplate{}, middleware.After) 675} 676 677func addOpUpdateSystemTemplateValidationMiddleware(stack *middleware.Stack) error { 678 return stack.Initialize.Add(&validateOpUpdateSystemTemplate{}, middleware.After) 679} 680 681func addOpUploadEntityDefinitionsValidationMiddleware(stack *middleware.Stack) error { 682 return stack.Initialize.Add(&validateOpUploadEntityDefinitions{}, middleware.After) 683} 684 685func validateDefinitionDocument(v *types.DefinitionDocument) error { 686 if v == nil { 687 return nil 688 } 689 invalidParams := smithy.InvalidParamsError{Context: "DefinitionDocument"} 690 if len(v.Language) == 0 { 691 invalidParams.Add(smithy.NewErrParamRequired("Language")) 692 } 693 if v.Text == nil { 694 invalidParams.Add(smithy.NewErrParamRequired("Text")) 695 } 696 if invalidParams.Len() > 0 { 697 return invalidParams 698 } else { 699 return nil 700 } 701} 702 703func validateFlowTemplateFilter(v *types.FlowTemplateFilter) error { 704 if v == nil { 705 return nil 706 } 707 invalidParams := smithy.InvalidParamsError{Context: "FlowTemplateFilter"} 708 if len(v.Name) == 0 { 709 invalidParams.Add(smithy.NewErrParamRequired("Name")) 710 } 711 if v.Value == nil { 712 invalidParams.Add(smithy.NewErrParamRequired("Value")) 713 } 714 if invalidParams.Len() > 0 { 715 return invalidParams 716 } else { 717 return nil 718 } 719} 720 721func validateFlowTemplateFilters(v []types.FlowTemplateFilter) error { 722 if v == nil { 723 return nil 724 } 725 invalidParams := smithy.InvalidParamsError{Context: "FlowTemplateFilters"} 726 for i := range v { 727 if err := validateFlowTemplateFilter(&v[i]); err != nil { 728 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 729 } 730 } 731 if invalidParams.Len() > 0 { 732 return invalidParams 733 } else { 734 return nil 735 } 736} 737 738func validateSystemTemplateFilter(v *types.SystemTemplateFilter) error { 739 if v == nil { 740 return nil 741 } 742 invalidParams := smithy.InvalidParamsError{Context: "SystemTemplateFilter"} 743 if len(v.Name) == 0 { 744 invalidParams.Add(smithy.NewErrParamRequired("Name")) 745 } 746 if v.Value == nil { 747 invalidParams.Add(smithy.NewErrParamRequired("Value")) 748 } 749 if invalidParams.Len() > 0 { 750 return invalidParams 751 } else { 752 return nil 753 } 754} 755 756func validateSystemTemplateFilters(v []types.SystemTemplateFilter) error { 757 if v == nil { 758 return nil 759 } 760 invalidParams := smithy.InvalidParamsError{Context: "SystemTemplateFilters"} 761 for i := range v { 762 if err := validateSystemTemplateFilter(&v[i]); err != nil { 763 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 764 } 765 } 766 if invalidParams.Len() > 0 { 767 return invalidParams 768 } else { 769 return nil 770 } 771} 772 773func validateTag(v *types.Tag) error { 774 if v == nil { 775 return nil 776 } 777 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 778 if v.Key == nil { 779 invalidParams.Add(smithy.NewErrParamRequired("Key")) 780 } 781 if v.Value == nil { 782 invalidParams.Add(smithy.NewErrParamRequired("Value")) 783 } 784 if invalidParams.Len() > 0 { 785 return invalidParams 786 } else { 787 return nil 788 } 789} 790 791func validateTagList(v []types.Tag) error { 792 if v == nil { 793 return nil 794 } 795 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 796 for i := range v { 797 if err := validateTag(&v[i]); err != nil { 798 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 799 } 800 } 801 if invalidParams.Len() > 0 { 802 return invalidParams 803 } else { 804 return nil 805 } 806} 807 808func validateOpAssociateEntityToThingInput(v *AssociateEntityToThingInput) error { 809 if v == nil { 810 return nil 811 } 812 invalidParams := smithy.InvalidParamsError{Context: "AssociateEntityToThingInput"} 813 if v.ThingName == nil { 814 invalidParams.Add(smithy.NewErrParamRequired("ThingName")) 815 } 816 if v.EntityId == nil { 817 invalidParams.Add(smithy.NewErrParamRequired("EntityId")) 818 } 819 if invalidParams.Len() > 0 { 820 return invalidParams 821 } else { 822 return nil 823 } 824} 825 826func validateOpCreateFlowTemplateInput(v *CreateFlowTemplateInput) error { 827 if v == nil { 828 return nil 829 } 830 invalidParams := smithy.InvalidParamsError{Context: "CreateFlowTemplateInput"} 831 if v.Definition == nil { 832 invalidParams.Add(smithy.NewErrParamRequired("Definition")) 833 } else if v.Definition != nil { 834 if err := validateDefinitionDocument(v.Definition); err != nil { 835 invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError)) 836 } 837 } 838 if invalidParams.Len() > 0 { 839 return invalidParams 840 } else { 841 return nil 842 } 843} 844 845func validateOpCreateSystemInstanceInput(v *CreateSystemInstanceInput) error { 846 if v == nil { 847 return nil 848 } 849 invalidParams := smithy.InvalidParamsError{Context: "CreateSystemInstanceInput"} 850 if v.Tags != nil { 851 if err := validateTagList(v.Tags); err != nil { 852 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 853 } 854 } 855 if v.Definition == nil { 856 invalidParams.Add(smithy.NewErrParamRequired("Definition")) 857 } else if v.Definition != nil { 858 if err := validateDefinitionDocument(v.Definition); err != nil { 859 invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError)) 860 } 861 } 862 if len(v.Target) == 0 { 863 invalidParams.Add(smithy.NewErrParamRequired("Target")) 864 } 865 if invalidParams.Len() > 0 { 866 return invalidParams 867 } else { 868 return nil 869 } 870} 871 872func validateOpCreateSystemTemplateInput(v *CreateSystemTemplateInput) error { 873 if v == nil { 874 return nil 875 } 876 invalidParams := smithy.InvalidParamsError{Context: "CreateSystemTemplateInput"} 877 if v.Definition == nil { 878 invalidParams.Add(smithy.NewErrParamRequired("Definition")) 879 } else if v.Definition != nil { 880 if err := validateDefinitionDocument(v.Definition); err != nil { 881 invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError)) 882 } 883 } 884 if invalidParams.Len() > 0 { 885 return invalidParams 886 } else { 887 return nil 888 } 889} 890 891func validateOpDeleteFlowTemplateInput(v *DeleteFlowTemplateInput) error { 892 if v == nil { 893 return nil 894 } 895 invalidParams := smithy.InvalidParamsError{Context: "DeleteFlowTemplateInput"} 896 if v.Id == nil { 897 invalidParams.Add(smithy.NewErrParamRequired("Id")) 898 } 899 if invalidParams.Len() > 0 { 900 return invalidParams 901 } else { 902 return nil 903 } 904} 905 906func validateOpDeleteSystemTemplateInput(v *DeleteSystemTemplateInput) error { 907 if v == nil { 908 return nil 909 } 910 invalidParams := smithy.InvalidParamsError{Context: "DeleteSystemTemplateInput"} 911 if v.Id == nil { 912 invalidParams.Add(smithy.NewErrParamRequired("Id")) 913 } 914 if invalidParams.Len() > 0 { 915 return invalidParams 916 } else { 917 return nil 918 } 919} 920 921func validateOpDeprecateFlowTemplateInput(v *DeprecateFlowTemplateInput) error { 922 if v == nil { 923 return nil 924 } 925 invalidParams := smithy.InvalidParamsError{Context: "DeprecateFlowTemplateInput"} 926 if v.Id == nil { 927 invalidParams.Add(smithy.NewErrParamRequired("Id")) 928 } 929 if invalidParams.Len() > 0 { 930 return invalidParams 931 } else { 932 return nil 933 } 934} 935 936func validateOpDeprecateSystemTemplateInput(v *DeprecateSystemTemplateInput) error { 937 if v == nil { 938 return nil 939 } 940 invalidParams := smithy.InvalidParamsError{Context: "DeprecateSystemTemplateInput"} 941 if v.Id == nil { 942 invalidParams.Add(smithy.NewErrParamRequired("Id")) 943 } 944 if invalidParams.Len() > 0 { 945 return invalidParams 946 } else { 947 return nil 948 } 949} 950 951func validateOpDissociateEntityFromThingInput(v *DissociateEntityFromThingInput) error { 952 if v == nil { 953 return nil 954 } 955 invalidParams := smithy.InvalidParamsError{Context: "DissociateEntityFromThingInput"} 956 if v.ThingName == nil { 957 invalidParams.Add(smithy.NewErrParamRequired("ThingName")) 958 } 959 if len(v.EntityType) == 0 { 960 invalidParams.Add(smithy.NewErrParamRequired("EntityType")) 961 } 962 if invalidParams.Len() > 0 { 963 return invalidParams 964 } else { 965 return nil 966 } 967} 968 969func validateOpGetEntitiesInput(v *GetEntitiesInput) error { 970 if v == nil { 971 return nil 972 } 973 invalidParams := smithy.InvalidParamsError{Context: "GetEntitiesInput"} 974 if v.Ids == nil { 975 invalidParams.Add(smithy.NewErrParamRequired("Ids")) 976 } 977 if invalidParams.Len() > 0 { 978 return invalidParams 979 } else { 980 return nil 981 } 982} 983 984func validateOpGetFlowTemplateInput(v *GetFlowTemplateInput) error { 985 if v == nil { 986 return nil 987 } 988 invalidParams := smithy.InvalidParamsError{Context: "GetFlowTemplateInput"} 989 if v.Id == nil { 990 invalidParams.Add(smithy.NewErrParamRequired("Id")) 991 } 992 if invalidParams.Len() > 0 { 993 return invalidParams 994 } else { 995 return nil 996 } 997} 998 999func validateOpGetFlowTemplateRevisionsInput(v *GetFlowTemplateRevisionsInput) error { 1000 if v == nil { 1001 return nil 1002 } 1003 invalidParams := smithy.InvalidParamsError{Context: "GetFlowTemplateRevisionsInput"} 1004 if v.Id == nil { 1005 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1006 } 1007 if invalidParams.Len() > 0 { 1008 return invalidParams 1009 } else { 1010 return nil 1011 } 1012} 1013 1014func validateOpGetSystemInstanceInput(v *GetSystemInstanceInput) error { 1015 if v == nil { 1016 return nil 1017 } 1018 invalidParams := smithy.InvalidParamsError{Context: "GetSystemInstanceInput"} 1019 if v.Id == nil { 1020 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1021 } 1022 if invalidParams.Len() > 0 { 1023 return invalidParams 1024 } else { 1025 return nil 1026 } 1027} 1028 1029func validateOpGetSystemTemplateInput(v *GetSystemTemplateInput) error { 1030 if v == nil { 1031 return nil 1032 } 1033 invalidParams := smithy.InvalidParamsError{Context: "GetSystemTemplateInput"} 1034 if v.Id == nil { 1035 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1036 } 1037 if invalidParams.Len() > 0 { 1038 return invalidParams 1039 } else { 1040 return nil 1041 } 1042} 1043 1044func validateOpGetSystemTemplateRevisionsInput(v *GetSystemTemplateRevisionsInput) error { 1045 if v == nil { 1046 return nil 1047 } 1048 invalidParams := smithy.InvalidParamsError{Context: "GetSystemTemplateRevisionsInput"} 1049 if v.Id == nil { 1050 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1051 } 1052 if invalidParams.Len() > 0 { 1053 return invalidParams 1054 } else { 1055 return nil 1056 } 1057} 1058 1059func validateOpGetUploadStatusInput(v *GetUploadStatusInput) error { 1060 if v == nil { 1061 return nil 1062 } 1063 invalidParams := smithy.InvalidParamsError{Context: "GetUploadStatusInput"} 1064 if v.UploadId == nil { 1065 invalidParams.Add(smithy.NewErrParamRequired("UploadId")) 1066 } 1067 if invalidParams.Len() > 0 { 1068 return invalidParams 1069 } else { 1070 return nil 1071 } 1072} 1073 1074func validateOpListFlowExecutionMessagesInput(v *ListFlowExecutionMessagesInput) error { 1075 if v == nil { 1076 return nil 1077 } 1078 invalidParams := smithy.InvalidParamsError{Context: "ListFlowExecutionMessagesInput"} 1079 if v.FlowExecutionId == nil { 1080 invalidParams.Add(smithy.NewErrParamRequired("FlowExecutionId")) 1081 } 1082 if invalidParams.Len() > 0 { 1083 return invalidParams 1084 } else { 1085 return nil 1086 } 1087} 1088 1089func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1090 if v == nil { 1091 return nil 1092 } 1093 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1094 if v.ResourceArn == nil { 1095 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1096 } 1097 if invalidParams.Len() > 0 { 1098 return invalidParams 1099 } else { 1100 return nil 1101 } 1102} 1103 1104func validateOpSearchEntitiesInput(v *SearchEntitiesInput) error { 1105 if v == nil { 1106 return nil 1107 } 1108 invalidParams := smithy.InvalidParamsError{Context: "SearchEntitiesInput"} 1109 if v.EntityTypes == nil { 1110 invalidParams.Add(smithy.NewErrParamRequired("EntityTypes")) 1111 } 1112 if invalidParams.Len() > 0 { 1113 return invalidParams 1114 } else { 1115 return nil 1116 } 1117} 1118 1119func validateOpSearchFlowExecutionsInput(v *SearchFlowExecutionsInput) error { 1120 if v == nil { 1121 return nil 1122 } 1123 invalidParams := smithy.InvalidParamsError{Context: "SearchFlowExecutionsInput"} 1124 if v.SystemInstanceId == nil { 1125 invalidParams.Add(smithy.NewErrParamRequired("SystemInstanceId")) 1126 } 1127 if invalidParams.Len() > 0 { 1128 return invalidParams 1129 } else { 1130 return nil 1131 } 1132} 1133 1134func validateOpSearchFlowTemplatesInput(v *SearchFlowTemplatesInput) error { 1135 if v == nil { 1136 return nil 1137 } 1138 invalidParams := smithy.InvalidParamsError{Context: "SearchFlowTemplatesInput"} 1139 if v.Filters != nil { 1140 if err := validateFlowTemplateFilters(v.Filters); err != nil { 1141 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1142 } 1143 } 1144 if invalidParams.Len() > 0 { 1145 return invalidParams 1146 } else { 1147 return nil 1148 } 1149} 1150 1151func validateOpSearchSystemTemplatesInput(v *SearchSystemTemplatesInput) error { 1152 if v == nil { 1153 return nil 1154 } 1155 invalidParams := smithy.InvalidParamsError{Context: "SearchSystemTemplatesInput"} 1156 if v.Filters != nil { 1157 if err := validateSystemTemplateFilters(v.Filters); err != nil { 1158 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1159 } 1160 } 1161 if invalidParams.Len() > 0 { 1162 return invalidParams 1163 } else { 1164 return nil 1165 } 1166} 1167 1168func validateOpSearchThingsInput(v *SearchThingsInput) error { 1169 if v == nil { 1170 return nil 1171 } 1172 invalidParams := smithy.InvalidParamsError{Context: "SearchThingsInput"} 1173 if v.EntityId == nil { 1174 invalidParams.Add(smithy.NewErrParamRequired("EntityId")) 1175 } 1176 if invalidParams.Len() > 0 { 1177 return invalidParams 1178 } else { 1179 return nil 1180 } 1181} 1182 1183func validateOpTagResourceInput(v *TagResourceInput) error { 1184 if v == nil { 1185 return nil 1186 } 1187 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1188 if v.ResourceArn == nil { 1189 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1190 } 1191 if v.Tags == nil { 1192 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1193 } else if v.Tags != nil { 1194 if err := validateTagList(v.Tags); err != nil { 1195 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1196 } 1197 } 1198 if invalidParams.Len() > 0 { 1199 return invalidParams 1200 } else { 1201 return nil 1202 } 1203} 1204 1205func validateOpUntagResourceInput(v *UntagResourceInput) error { 1206 if v == nil { 1207 return nil 1208 } 1209 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1210 if v.ResourceArn == nil { 1211 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1212 } 1213 if v.TagKeys == nil { 1214 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1215 } 1216 if invalidParams.Len() > 0 { 1217 return invalidParams 1218 } else { 1219 return nil 1220 } 1221} 1222 1223func validateOpUpdateFlowTemplateInput(v *UpdateFlowTemplateInput) error { 1224 if v == nil { 1225 return nil 1226 } 1227 invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowTemplateInput"} 1228 if v.Id == nil { 1229 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1230 } 1231 if v.Definition == nil { 1232 invalidParams.Add(smithy.NewErrParamRequired("Definition")) 1233 } else if v.Definition != nil { 1234 if err := validateDefinitionDocument(v.Definition); err != nil { 1235 invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError)) 1236 } 1237 } 1238 if invalidParams.Len() > 0 { 1239 return invalidParams 1240 } else { 1241 return nil 1242 } 1243} 1244 1245func validateOpUpdateSystemTemplateInput(v *UpdateSystemTemplateInput) error { 1246 if v == nil { 1247 return nil 1248 } 1249 invalidParams := smithy.InvalidParamsError{Context: "UpdateSystemTemplateInput"} 1250 if v.Id == nil { 1251 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1252 } 1253 if v.Definition == nil { 1254 invalidParams.Add(smithy.NewErrParamRequired("Definition")) 1255 } else if v.Definition != nil { 1256 if err := validateDefinitionDocument(v.Definition); err != nil { 1257 invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError)) 1258 } 1259 } 1260 if invalidParams.Len() > 0 { 1261 return invalidParams 1262 } else { 1263 return nil 1264 } 1265} 1266 1267func validateOpUploadEntityDefinitionsInput(v *UploadEntityDefinitionsInput) error { 1268 if v == nil { 1269 return nil 1270 } 1271 invalidParams := smithy.InvalidParamsError{Context: "UploadEntityDefinitionsInput"} 1272 if v.Document != nil { 1273 if err := validateDefinitionDocument(v.Document); err != nil { 1274 invalidParams.AddNested("Document", err.(smithy.InvalidParamsError)) 1275 } 1276 } 1277 if invalidParams.Len() > 0 { 1278 return invalidParams 1279 } else { 1280 return nil 1281 } 1282} 1283