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