validators.go (80619B)
1 // Code generated by smithy-go-codegen DO NOT EDIT. 2 3 package route53 4 5 import ( 6 "context" 7 "fmt" 8 9 "github.com/aws/aws-sdk-go-v2/service/route53/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/middleware" 12 ) 13 14 type validateOpActivateKeySigningKey struct { 15 } 16 17 func (*validateOpActivateKeySigningKey) ID() string { 18 return "OperationInputValidation" 19 } 20 21 func (m *validateOpActivateKeySigningKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 22 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 23 ) { 24 input, ok := in.Parameters.(*ActivateKeySigningKeyInput) 25 if !ok { 26 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 27 } 28 if err := validateOpActivateKeySigningKeyInput(input); err != nil { 29 return out, metadata, err 30 } 31 return next.HandleInitialize(ctx, in) 32 } 33 34 type validateOpAssociateVPCWithHostedZone struct { 35 } 36 37 func (*validateOpAssociateVPCWithHostedZone) ID() string { 38 return "OperationInputValidation" 39 } 40 41 func (m *validateOpAssociateVPCWithHostedZone) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 42 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 43 ) { 44 input, ok := in.Parameters.(*AssociateVPCWithHostedZoneInput) 45 if !ok { 46 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 47 } 48 if err := validateOpAssociateVPCWithHostedZoneInput(input); err != nil { 49 return out, metadata, err 50 } 51 return next.HandleInitialize(ctx, in) 52 } 53 54 type validateOpChangeCidrCollection struct { 55 } 56 57 func (*validateOpChangeCidrCollection) ID() string { 58 return "OperationInputValidation" 59 } 60 61 func (m *validateOpChangeCidrCollection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 62 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 63 ) { 64 input, ok := in.Parameters.(*ChangeCidrCollectionInput) 65 if !ok { 66 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 67 } 68 if err := validateOpChangeCidrCollectionInput(input); err != nil { 69 return out, metadata, err 70 } 71 return next.HandleInitialize(ctx, in) 72 } 73 74 type validateOpChangeResourceRecordSets struct { 75 } 76 77 func (*validateOpChangeResourceRecordSets) ID() string { 78 return "OperationInputValidation" 79 } 80 81 func (m *validateOpChangeResourceRecordSets) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 82 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 83 ) { 84 input, ok := in.Parameters.(*ChangeResourceRecordSetsInput) 85 if !ok { 86 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 87 } 88 if err := validateOpChangeResourceRecordSetsInput(input); err != nil { 89 return out, metadata, err 90 } 91 return next.HandleInitialize(ctx, in) 92 } 93 94 type validateOpChangeTagsForResource struct { 95 } 96 97 func (*validateOpChangeTagsForResource) ID() string { 98 return "OperationInputValidation" 99 } 100 101 func (m *validateOpChangeTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 102 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 103 ) { 104 input, ok := in.Parameters.(*ChangeTagsForResourceInput) 105 if !ok { 106 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 107 } 108 if err := validateOpChangeTagsForResourceInput(input); err != nil { 109 return out, metadata, err 110 } 111 return next.HandleInitialize(ctx, in) 112 } 113 114 type validateOpCreateCidrCollection struct { 115 } 116 117 func (*validateOpCreateCidrCollection) ID() string { 118 return "OperationInputValidation" 119 } 120 121 func (m *validateOpCreateCidrCollection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 122 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 123 ) { 124 input, ok := in.Parameters.(*CreateCidrCollectionInput) 125 if !ok { 126 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 127 } 128 if err := validateOpCreateCidrCollectionInput(input); err != nil { 129 return out, metadata, err 130 } 131 return next.HandleInitialize(ctx, in) 132 } 133 134 type validateOpCreateHealthCheck struct { 135 } 136 137 func (*validateOpCreateHealthCheck) ID() string { 138 return "OperationInputValidation" 139 } 140 141 func (m *validateOpCreateHealthCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 142 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 143 ) { 144 input, ok := in.Parameters.(*CreateHealthCheckInput) 145 if !ok { 146 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 147 } 148 if err := validateOpCreateHealthCheckInput(input); err != nil { 149 return out, metadata, err 150 } 151 return next.HandleInitialize(ctx, in) 152 } 153 154 type validateOpCreateHostedZone struct { 155 } 156 157 func (*validateOpCreateHostedZone) ID() string { 158 return "OperationInputValidation" 159 } 160 161 func (m *validateOpCreateHostedZone) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 162 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 163 ) { 164 input, ok := in.Parameters.(*CreateHostedZoneInput) 165 if !ok { 166 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 167 } 168 if err := validateOpCreateHostedZoneInput(input); err != nil { 169 return out, metadata, err 170 } 171 return next.HandleInitialize(ctx, in) 172 } 173 174 type validateOpCreateKeySigningKey struct { 175 } 176 177 func (*validateOpCreateKeySigningKey) ID() string { 178 return "OperationInputValidation" 179 } 180 181 func (m *validateOpCreateKeySigningKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 182 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 183 ) { 184 input, ok := in.Parameters.(*CreateKeySigningKeyInput) 185 if !ok { 186 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 187 } 188 if err := validateOpCreateKeySigningKeyInput(input); err != nil { 189 return out, metadata, err 190 } 191 return next.HandleInitialize(ctx, in) 192 } 193 194 type validateOpCreateQueryLoggingConfig struct { 195 } 196 197 func (*validateOpCreateQueryLoggingConfig) ID() string { 198 return "OperationInputValidation" 199 } 200 201 func (m *validateOpCreateQueryLoggingConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 202 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 203 ) { 204 input, ok := in.Parameters.(*CreateQueryLoggingConfigInput) 205 if !ok { 206 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 207 } 208 if err := validateOpCreateQueryLoggingConfigInput(input); err != nil { 209 return out, metadata, err 210 } 211 return next.HandleInitialize(ctx, in) 212 } 213 214 type validateOpCreateReusableDelegationSet struct { 215 } 216 217 func (*validateOpCreateReusableDelegationSet) ID() string { 218 return "OperationInputValidation" 219 } 220 221 func (m *validateOpCreateReusableDelegationSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 222 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 223 ) { 224 input, ok := in.Parameters.(*CreateReusableDelegationSetInput) 225 if !ok { 226 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 227 } 228 if err := validateOpCreateReusableDelegationSetInput(input); err != nil { 229 return out, metadata, err 230 } 231 return next.HandleInitialize(ctx, in) 232 } 233 234 type validateOpCreateTrafficPolicy struct { 235 } 236 237 func (*validateOpCreateTrafficPolicy) ID() string { 238 return "OperationInputValidation" 239 } 240 241 func (m *validateOpCreateTrafficPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 242 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 243 ) { 244 input, ok := in.Parameters.(*CreateTrafficPolicyInput) 245 if !ok { 246 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 247 } 248 if err := validateOpCreateTrafficPolicyInput(input); err != nil { 249 return out, metadata, err 250 } 251 return next.HandleInitialize(ctx, in) 252 } 253 254 type validateOpCreateTrafficPolicyInstance struct { 255 } 256 257 func (*validateOpCreateTrafficPolicyInstance) ID() string { 258 return "OperationInputValidation" 259 } 260 261 func (m *validateOpCreateTrafficPolicyInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 262 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 263 ) { 264 input, ok := in.Parameters.(*CreateTrafficPolicyInstanceInput) 265 if !ok { 266 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 267 } 268 if err := validateOpCreateTrafficPolicyInstanceInput(input); err != nil { 269 return out, metadata, err 270 } 271 return next.HandleInitialize(ctx, in) 272 } 273 274 type validateOpCreateTrafficPolicyVersion struct { 275 } 276 277 func (*validateOpCreateTrafficPolicyVersion) ID() string { 278 return "OperationInputValidation" 279 } 280 281 func (m *validateOpCreateTrafficPolicyVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 282 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 283 ) { 284 input, ok := in.Parameters.(*CreateTrafficPolicyVersionInput) 285 if !ok { 286 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 287 } 288 if err := validateOpCreateTrafficPolicyVersionInput(input); err != nil { 289 return out, metadata, err 290 } 291 return next.HandleInitialize(ctx, in) 292 } 293 294 type validateOpCreateVPCAssociationAuthorization struct { 295 } 296 297 func (*validateOpCreateVPCAssociationAuthorization) ID() string { 298 return "OperationInputValidation" 299 } 300 301 func (m *validateOpCreateVPCAssociationAuthorization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 302 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 303 ) { 304 input, ok := in.Parameters.(*CreateVPCAssociationAuthorizationInput) 305 if !ok { 306 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 307 } 308 if err := validateOpCreateVPCAssociationAuthorizationInput(input); err != nil { 309 return out, metadata, err 310 } 311 return next.HandleInitialize(ctx, in) 312 } 313 314 type validateOpDeactivateKeySigningKey struct { 315 } 316 317 func (*validateOpDeactivateKeySigningKey) ID() string { 318 return "OperationInputValidation" 319 } 320 321 func (m *validateOpDeactivateKeySigningKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 322 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 323 ) { 324 input, ok := in.Parameters.(*DeactivateKeySigningKeyInput) 325 if !ok { 326 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 327 } 328 if err := validateOpDeactivateKeySigningKeyInput(input); err != nil { 329 return out, metadata, err 330 } 331 return next.HandleInitialize(ctx, in) 332 } 333 334 type validateOpDeleteCidrCollection struct { 335 } 336 337 func (*validateOpDeleteCidrCollection) ID() string { 338 return "OperationInputValidation" 339 } 340 341 func (m *validateOpDeleteCidrCollection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 342 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 343 ) { 344 input, ok := in.Parameters.(*DeleteCidrCollectionInput) 345 if !ok { 346 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 347 } 348 if err := validateOpDeleteCidrCollectionInput(input); err != nil { 349 return out, metadata, err 350 } 351 return next.HandleInitialize(ctx, in) 352 } 353 354 type validateOpDeleteHealthCheck struct { 355 } 356 357 func (*validateOpDeleteHealthCheck) ID() string { 358 return "OperationInputValidation" 359 } 360 361 func (m *validateOpDeleteHealthCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 362 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 363 ) { 364 input, ok := in.Parameters.(*DeleteHealthCheckInput) 365 if !ok { 366 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 367 } 368 if err := validateOpDeleteHealthCheckInput(input); err != nil { 369 return out, metadata, err 370 } 371 return next.HandleInitialize(ctx, in) 372 } 373 374 type validateOpDeleteHostedZone struct { 375 } 376 377 func (*validateOpDeleteHostedZone) ID() string { 378 return "OperationInputValidation" 379 } 380 381 func (m *validateOpDeleteHostedZone) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 382 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 383 ) { 384 input, ok := in.Parameters.(*DeleteHostedZoneInput) 385 if !ok { 386 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 387 } 388 if err := validateOpDeleteHostedZoneInput(input); err != nil { 389 return out, metadata, err 390 } 391 return next.HandleInitialize(ctx, in) 392 } 393 394 type validateOpDeleteKeySigningKey struct { 395 } 396 397 func (*validateOpDeleteKeySigningKey) ID() string { 398 return "OperationInputValidation" 399 } 400 401 func (m *validateOpDeleteKeySigningKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 402 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 403 ) { 404 input, ok := in.Parameters.(*DeleteKeySigningKeyInput) 405 if !ok { 406 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 407 } 408 if err := validateOpDeleteKeySigningKeyInput(input); err != nil { 409 return out, metadata, err 410 } 411 return next.HandleInitialize(ctx, in) 412 } 413 414 type validateOpDeleteQueryLoggingConfig struct { 415 } 416 417 func (*validateOpDeleteQueryLoggingConfig) ID() string { 418 return "OperationInputValidation" 419 } 420 421 func (m *validateOpDeleteQueryLoggingConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 422 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 423 ) { 424 input, ok := in.Parameters.(*DeleteQueryLoggingConfigInput) 425 if !ok { 426 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 427 } 428 if err := validateOpDeleteQueryLoggingConfigInput(input); err != nil { 429 return out, metadata, err 430 } 431 return next.HandleInitialize(ctx, in) 432 } 433 434 type validateOpDeleteReusableDelegationSet struct { 435 } 436 437 func (*validateOpDeleteReusableDelegationSet) ID() string { 438 return "OperationInputValidation" 439 } 440 441 func (m *validateOpDeleteReusableDelegationSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 442 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 443 ) { 444 input, ok := in.Parameters.(*DeleteReusableDelegationSetInput) 445 if !ok { 446 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 447 } 448 if err := validateOpDeleteReusableDelegationSetInput(input); err != nil { 449 return out, metadata, err 450 } 451 return next.HandleInitialize(ctx, in) 452 } 453 454 type validateOpDeleteTrafficPolicy struct { 455 } 456 457 func (*validateOpDeleteTrafficPolicy) ID() string { 458 return "OperationInputValidation" 459 } 460 461 func (m *validateOpDeleteTrafficPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 462 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 463 ) { 464 input, ok := in.Parameters.(*DeleteTrafficPolicyInput) 465 if !ok { 466 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 467 } 468 if err := validateOpDeleteTrafficPolicyInput(input); err != nil { 469 return out, metadata, err 470 } 471 return next.HandleInitialize(ctx, in) 472 } 473 474 type validateOpDeleteTrafficPolicyInstance struct { 475 } 476 477 func (*validateOpDeleteTrafficPolicyInstance) ID() string { 478 return "OperationInputValidation" 479 } 480 481 func (m *validateOpDeleteTrafficPolicyInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 482 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 483 ) { 484 input, ok := in.Parameters.(*DeleteTrafficPolicyInstanceInput) 485 if !ok { 486 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 487 } 488 if err := validateOpDeleteTrafficPolicyInstanceInput(input); err != nil { 489 return out, metadata, err 490 } 491 return next.HandleInitialize(ctx, in) 492 } 493 494 type validateOpDeleteVPCAssociationAuthorization struct { 495 } 496 497 func (*validateOpDeleteVPCAssociationAuthorization) ID() string { 498 return "OperationInputValidation" 499 } 500 501 func (m *validateOpDeleteVPCAssociationAuthorization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 502 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 503 ) { 504 input, ok := in.Parameters.(*DeleteVPCAssociationAuthorizationInput) 505 if !ok { 506 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 507 } 508 if err := validateOpDeleteVPCAssociationAuthorizationInput(input); err != nil { 509 return out, metadata, err 510 } 511 return next.HandleInitialize(ctx, in) 512 } 513 514 type validateOpDisableHostedZoneDNSSEC struct { 515 } 516 517 func (*validateOpDisableHostedZoneDNSSEC) ID() string { 518 return "OperationInputValidation" 519 } 520 521 func (m *validateOpDisableHostedZoneDNSSEC) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 522 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 523 ) { 524 input, ok := in.Parameters.(*DisableHostedZoneDNSSECInput) 525 if !ok { 526 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 527 } 528 if err := validateOpDisableHostedZoneDNSSECInput(input); err != nil { 529 return out, metadata, err 530 } 531 return next.HandleInitialize(ctx, in) 532 } 533 534 type validateOpDisassociateVPCFromHostedZone struct { 535 } 536 537 func (*validateOpDisassociateVPCFromHostedZone) ID() string { 538 return "OperationInputValidation" 539 } 540 541 func (m *validateOpDisassociateVPCFromHostedZone) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 542 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 543 ) { 544 input, ok := in.Parameters.(*DisassociateVPCFromHostedZoneInput) 545 if !ok { 546 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 547 } 548 if err := validateOpDisassociateVPCFromHostedZoneInput(input); err != nil { 549 return out, metadata, err 550 } 551 return next.HandleInitialize(ctx, in) 552 } 553 554 type validateOpEnableHostedZoneDNSSEC struct { 555 } 556 557 func (*validateOpEnableHostedZoneDNSSEC) ID() string { 558 return "OperationInputValidation" 559 } 560 561 func (m *validateOpEnableHostedZoneDNSSEC) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 562 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 563 ) { 564 input, ok := in.Parameters.(*EnableHostedZoneDNSSECInput) 565 if !ok { 566 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 567 } 568 if err := validateOpEnableHostedZoneDNSSECInput(input); err != nil { 569 return out, metadata, err 570 } 571 return next.HandleInitialize(ctx, in) 572 } 573 574 type validateOpGetAccountLimit struct { 575 } 576 577 func (*validateOpGetAccountLimit) ID() string { 578 return "OperationInputValidation" 579 } 580 581 func (m *validateOpGetAccountLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 582 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 583 ) { 584 input, ok := in.Parameters.(*GetAccountLimitInput) 585 if !ok { 586 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 587 } 588 if err := validateOpGetAccountLimitInput(input); err != nil { 589 return out, metadata, err 590 } 591 return next.HandleInitialize(ctx, in) 592 } 593 594 type validateOpGetChange struct { 595 } 596 597 func (*validateOpGetChange) ID() string { 598 return "OperationInputValidation" 599 } 600 601 func (m *validateOpGetChange) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 602 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 603 ) { 604 input, ok := in.Parameters.(*GetChangeInput) 605 if !ok { 606 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 607 } 608 if err := validateOpGetChangeInput(input); err != nil { 609 return out, metadata, err 610 } 611 return next.HandleInitialize(ctx, in) 612 } 613 614 type validateOpGetDNSSEC struct { 615 } 616 617 func (*validateOpGetDNSSEC) ID() string { 618 return "OperationInputValidation" 619 } 620 621 func (m *validateOpGetDNSSEC) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 622 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 623 ) { 624 input, ok := in.Parameters.(*GetDNSSECInput) 625 if !ok { 626 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 627 } 628 if err := validateOpGetDNSSECInput(input); err != nil { 629 return out, metadata, err 630 } 631 return next.HandleInitialize(ctx, in) 632 } 633 634 type validateOpGetHealthCheck struct { 635 } 636 637 func (*validateOpGetHealthCheck) ID() string { 638 return "OperationInputValidation" 639 } 640 641 func (m *validateOpGetHealthCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 642 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 643 ) { 644 input, ok := in.Parameters.(*GetHealthCheckInput) 645 if !ok { 646 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 647 } 648 if err := validateOpGetHealthCheckInput(input); err != nil { 649 return out, metadata, err 650 } 651 return next.HandleInitialize(ctx, in) 652 } 653 654 type validateOpGetHealthCheckLastFailureReason struct { 655 } 656 657 func (*validateOpGetHealthCheckLastFailureReason) ID() string { 658 return "OperationInputValidation" 659 } 660 661 func (m *validateOpGetHealthCheckLastFailureReason) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 662 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 663 ) { 664 input, ok := in.Parameters.(*GetHealthCheckLastFailureReasonInput) 665 if !ok { 666 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 667 } 668 if err := validateOpGetHealthCheckLastFailureReasonInput(input); err != nil { 669 return out, metadata, err 670 } 671 return next.HandleInitialize(ctx, in) 672 } 673 674 type validateOpGetHealthCheckStatus struct { 675 } 676 677 func (*validateOpGetHealthCheckStatus) ID() string { 678 return "OperationInputValidation" 679 } 680 681 func (m *validateOpGetHealthCheckStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 682 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 683 ) { 684 input, ok := in.Parameters.(*GetHealthCheckStatusInput) 685 if !ok { 686 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 687 } 688 if err := validateOpGetHealthCheckStatusInput(input); err != nil { 689 return out, metadata, err 690 } 691 return next.HandleInitialize(ctx, in) 692 } 693 694 type validateOpGetHostedZone struct { 695 } 696 697 func (*validateOpGetHostedZone) ID() string { 698 return "OperationInputValidation" 699 } 700 701 func (m *validateOpGetHostedZone) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 702 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 703 ) { 704 input, ok := in.Parameters.(*GetHostedZoneInput) 705 if !ok { 706 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 707 } 708 if err := validateOpGetHostedZoneInput(input); err != nil { 709 return out, metadata, err 710 } 711 return next.HandleInitialize(ctx, in) 712 } 713 714 type validateOpGetHostedZoneLimit struct { 715 } 716 717 func (*validateOpGetHostedZoneLimit) ID() string { 718 return "OperationInputValidation" 719 } 720 721 func (m *validateOpGetHostedZoneLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 722 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 723 ) { 724 input, ok := in.Parameters.(*GetHostedZoneLimitInput) 725 if !ok { 726 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 727 } 728 if err := validateOpGetHostedZoneLimitInput(input); err != nil { 729 return out, metadata, err 730 } 731 return next.HandleInitialize(ctx, in) 732 } 733 734 type validateOpGetQueryLoggingConfig struct { 735 } 736 737 func (*validateOpGetQueryLoggingConfig) ID() string { 738 return "OperationInputValidation" 739 } 740 741 func (m *validateOpGetQueryLoggingConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 742 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 743 ) { 744 input, ok := in.Parameters.(*GetQueryLoggingConfigInput) 745 if !ok { 746 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 747 } 748 if err := validateOpGetQueryLoggingConfigInput(input); err != nil { 749 return out, metadata, err 750 } 751 return next.HandleInitialize(ctx, in) 752 } 753 754 type validateOpGetReusableDelegationSet struct { 755 } 756 757 func (*validateOpGetReusableDelegationSet) ID() string { 758 return "OperationInputValidation" 759 } 760 761 func (m *validateOpGetReusableDelegationSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 762 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 763 ) { 764 input, ok := in.Parameters.(*GetReusableDelegationSetInput) 765 if !ok { 766 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 767 } 768 if err := validateOpGetReusableDelegationSetInput(input); err != nil { 769 return out, metadata, err 770 } 771 return next.HandleInitialize(ctx, in) 772 } 773 774 type validateOpGetReusableDelegationSetLimit struct { 775 } 776 777 func (*validateOpGetReusableDelegationSetLimit) ID() string { 778 return "OperationInputValidation" 779 } 780 781 func (m *validateOpGetReusableDelegationSetLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 782 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 783 ) { 784 input, ok := in.Parameters.(*GetReusableDelegationSetLimitInput) 785 if !ok { 786 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 787 } 788 if err := validateOpGetReusableDelegationSetLimitInput(input); err != nil { 789 return out, metadata, err 790 } 791 return next.HandleInitialize(ctx, in) 792 } 793 794 type validateOpGetTrafficPolicy struct { 795 } 796 797 func (*validateOpGetTrafficPolicy) ID() string { 798 return "OperationInputValidation" 799 } 800 801 func (m *validateOpGetTrafficPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 802 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 803 ) { 804 input, ok := in.Parameters.(*GetTrafficPolicyInput) 805 if !ok { 806 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 807 } 808 if err := validateOpGetTrafficPolicyInput(input); err != nil { 809 return out, metadata, err 810 } 811 return next.HandleInitialize(ctx, in) 812 } 813 814 type validateOpGetTrafficPolicyInstance struct { 815 } 816 817 func (*validateOpGetTrafficPolicyInstance) ID() string { 818 return "OperationInputValidation" 819 } 820 821 func (m *validateOpGetTrafficPolicyInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 822 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 823 ) { 824 input, ok := in.Parameters.(*GetTrafficPolicyInstanceInput) 825 if !ok { 826 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 827 } 828 if err := validateOpGetTrafficPolicyInstanceInput(input); err != nil { 829 return out, metadata, err 830 } 831 return next.HandleInitialize(ctx, in) 832 } 833 834 type validateOpListCidrBlocks struct { 835 } 836 837 func (*validateOpListCidrBlocks) ID() string { 838 return "OperationInputValidation" 839 } 840 841 func (m *validateOpListCidrBlocks) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 842 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 843 ) { 844 input, ok := in.Parameters.(*ListCidrBlocksInput) 845 if !ok { 846 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 847 } 848 if err := validateOpListCidrBlocksInput(input); err != nil { 849 return out, metadata, err 850 } 851 return next.HandleInitialize(ctx, in) 852 } 853 854 type validateOpListCidrLocations struct { 855 } 856 857 func (*validateOpListCidrLocations) ID() string { 858 return "OperationInputValidation" 859 } 860 861 func (m *validateOpListCidrLocations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 862 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 863 ) { 864 input, ok := in.Parameters.(*ListCidrLocationsInput) 865 if !ok { 866 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 867 } 868 if err := validateOpListCidrLocationsInput(input); err != nil { 869 return out, metadata, err 870 } 871 return next.HandleInitialize(ctx, in) 872 } 873 874 type validateOpListHostedZonesByVPC struct { 875 } 876 877 func (*validateOpListHostedZonesByVPC) ID() string { 878 return "OperationInputValidation" 879 } 880 881 func (m *validateOpListHostedZonesByVPC) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 882 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 883 ) { 884 input, ok := in.Parameters.(*ListHostedZonesByVPCInput) 885 if !ok { 886 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 887 } 888 if err := validateOpListHostedZonesByVPCInput(input); err != nil { 889 return out, metadata, err 890 } 891 return next.HandleInitialize(ctx, in) 892 } 893 894 type validateOpListResourceRecordSets struct { 895 } 896 897 func (*validateOpListResourceRecordSets) ID() string { 898 return "OperationInputValidation" 899 } 900 901 func (m *validateOpListResourceRecordSets) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 902 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 903 ) { 904 input, ok := in.Parameters.(*ListResourceRecordSetsInput) 905 if !ok { 906 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 907 } 908 if err := validateOpListResourceRecordSetsInput(input); err != nil { 909 return out, metadata, err 910 } 911 return next.HandleInitialize(ctx, in) 912 } 913 914 type validateOpListTagsForResource struct { 915 } 916 917 func (*validateOpListTagsForResource) ID() string { 918 return "OperationInputValidation" 919 } 920 921 func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 922 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 923 ) { 924 input, ok := in.Parameters.(*ListTagsForResourceInput) 925 if !ok { 926 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 927 } 928 if err := validateOpListTagsForResourceInput(input); err != nil { 929 return out, metadata, err 930 } 931 return next.HandleInitialize(ctx, in) 932 } 933 934 type validateOpListTagsForResources struct { 935 } 936 937 func (*validateOpListTagsForResources) ID() string { 938 return "OperationInputValidation" 939 } 940 941 func (m *validateOpListTagsForResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 942 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 943 ) { 944 input, ok := in.Parameters.(*ListTagsForResourcesInput) 945 if !ok { 946 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 947 } 948 if err := validateOpListTagsForResourcesInput(input); err != nil { 949 return out, metadata, err 950 } 951 return next.HandleInitialize(ctx, in) 952 } 953 954 type validateOpListTrafficPolicyInstancesByHostedZone struct { 955 } 956 957 func (*validateOpListTrafficPolicyInstancesByHostedZone) ID() string { 958 return "OperationInputValidation" 959 } 960 961 func (m *validateOpListTrafficPolicyInstancesByHostedZone) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 962 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 963 ) { 964 input, ok := in.Parameters.(*ListTrafficPolicyInstancesByHostedZoneInput) 965 if !ok { 966 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 967 } 968 if err := validateOpListTrafficPolicyInstancesByHostedZoneInput(input); err != nil { 969 return out, metadata, err 970 } 971 return next.HandleInitialize(ctx, in) 972 } 973 974 type validateOpListTrafficPolicyInstancesByPolicy struct { 975 } 976 977 func (*validateOpListTrafficPolicyInstancesByPolicy) ID() string { 978 return "OperationInputValidation" 979 } 980 981 func (m *validateOpListTrafficPolicyInstancesByPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 982 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 983 ) { 984 input, ok := in.Parameters.(*ListTrafficPolicyInstancesByPolicyInput) 985 if !ok { 986 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 987 } 988 if err := validateOpListTrafficPolicyInstancesByPolicyInput(input); err != nil { 989 return out, metadata, err 990 } 991 return next.HandleInitialize(ctx, in) 992 } 993 994 type validateOpListTrafficPolicyVersions struct { 995 } 996 997 func (*validateOpListTrafficPolicyVersions) ID() string { 998 return "OperationInputValidation" 999 } 1000 1001 func (m *validateOpListTrafficPolicyVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1002 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1003 ) { 1004 input, ok := in.Parameters.(*ListTrafficPolicyVersionsInput) 1005 if !ok { 1006 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1007 } 1008 if err := validateOpListTrafficPolicyVersionsInput(input); err != nil { 1009 return out, metadata, err 1010 } 1011 return next.HandleInitialize(ctx, in) 1012 } 1013 1014 type validateOpListVPCAssociationAuthorizations struct { 1015 } 1016 1017 func (*validateOpListVPCAssociationAuthorizations) ID() string { 1018 return "OperationInputValidation" 1019 } 1020 1021 func (m *validateOpListVPCAssociationAuthorizations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1022 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1023 ) { 1024 input, ok := in.Parameters.(*ListVPCAssociationAuthorizationsInput) 1025 if !ok { 1026 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1027 } 1028 if err := validateOpListVPCAssociationAuthorizationsInput(input); err != nil { 1029 return out, metadata, err 1030 } 1031 return next.HandleInitialize(ctx, in) 1032 } 1033 1034 type validateOpTestDNSAnswer struct { 1035 } 1036 1037 func (*validateOpTestDNSAnswer) ID() string { 1038 return "OperationInputValidation" 1039 } 1040 1041 func (m *validateOpTestDNSAnswer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1042 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1043 ) { 1044 input, ok := in.Parameters.(*TestDNSAnswerInput) 1045 if !ok { 1046 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1047 } 1048 if err := validateOpTestDNSAnswerInput(input); err != nil { 1049 return out, metadata, err 1050 } 1051 return next.HandleInitialize(ctx, in) 1052 } 1053 1054 type validateOpUpdateHealthCheck struct { 1055 } 1056 1057 func (*validateOpUpdateHealthCheck) ID() string { 1058 return "OperationInputValidation" 1059 } 1060 1061 func (m *validateOpUpdateHealthCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1062 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1063 ) { 1064 input, ok := in.Parameters.(*UpdateHealthCheckInput) 1065 if !ok { 1066 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1067 } 1068 if err := validateOpUpdateHealthCheckInput(input); err != nil { 1069 return out, metadata, err 1070 } 1071 return next.HandleInitialize(ctx, in) 1072 } 1073 1074 type validateOpUpdateHostedZoneComment struct { 1075 } 1076 1077 func (*validateOpUpdateHostedZoneComment) ID() string { 1078 return "OperationInputValidation" 1079 } 1080 1081 func (m *validateOpUpdateHostedZoneComment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1082 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1083 ) { 1084 input, ok := in.Parameters.(*UpdateHostedZoneCommentInput) 1085 if !ok { 1086 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1087 } 1088 if err := validateOpUpdateHostedZoneCommentInput(input); err != nil { 1089 return out, metadata, err 1090 } 1091 return next.HandleInitialize(ctx, in) 1092 } 1093 1094 type validateOpUpdateHostedZoneFeatures struct { 1095 } 1096 1097 func (*validateOpUpdateHostedZoneFeatures) ID() string { 1098 return "OperationInputValidation" 1099 } 1100 1101 func (m *validateOpUpdateHostedZoneFeatures) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1102 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1103 ) { 1104 input, ok := in.Parameters.(*UpdateHostedZoneFeaturesInput) 1105 if !ok { 1106 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1107 } 1108 if err := validateOpUpdateHostedZoneFeaturesInput(input); err != nil { 1109 return out, metadata, err 1110 } 1111 return next.HandleInitialize(ctx, in) 1112 } 1113 1114 type validateOpUpdateTrafficPolicyComment struct { 1115 } 1116 1117 func (*validateOpUpdateTrafficPolicyComment) ID() string { 1118 return "OperationInputValidation" 1119 } 1120 1121 func (m *validateOpUpdateTrafficPolicyComment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1122 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1123 ) { 1124 input, ok := in.Parameters.(*UpdateTrafficPolicyCommentInput) 1125 if !ok { 1126 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1127 } 1128 if err := validateOpUpdateTrafficPolicyCommentInput(input); err != nil { 1129 return out, metadata, err 1130 } 1131 return next.HandleInitialize(ctx, in) 1132 } 1133 1134 type validateOpUpdateTrafficPolicyInstance struct { 1135 } 1136 1137 func (*validateOpUpdateTrafficPolicyInstance) ID() string { 1138 return "OperationInputValidation" 1139 } 1140 1141 func (m *validateOpUpdateTrafficPolicyInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1142 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1143 ) { 1144 input, ok := in.Parameters.(*UpdateTrafficPolicyInstanceInput) 1145 if !ok { 1146 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1147 } 1148 if err := validateOpUpdateTrafficPolicyInstanceInput(input); err != nil { 1149 return out, metadata, err 1150 } 1151 return next.HandleInitialize(ctx, in) 1152 } 1153 1154 func addOpActivateKeySigningKeyValidationMiddleware(stack *middleware.Stack) error { 1155 return stack.Initialize.Add(&validateOpActivateKeySigningKey{}, middleware.After) 1156 } 1157 1158 func addOpAssociateVPCWithHostedZoneValidationMiddleware(stack *middleware.Stack) error { 1159 return stack.Initialize.Add(&validateOpAssociateVPCWithHostedZone{}, middleware.After) 1160 } 1161 1162 func addOpChangeCidrCollectionValidationMiddleware(stack *middleware.Stack) error { 1163 return stack.Initialize.Add(&validateOpChangeCidrCollection{}, middleware.After) 1164 } 1165 1166 func addOpChangeResourceRecordSetsValidationMiddleware(stack *middleware.Stack) error { 1167 return stack.Initialize.Add(&validateOpChangeResourceRecordSets{}, middleware.After) 1168 } 1169 1170 func addOpChangeTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 1171 return stack.Initialize.Add(&validateOpChangeTagsForResource{}, middleware.After) 1172 } 1173 1174 func addOpCreateCidrCollectionValidationMiddleware(stack *middleware.Stack) error { 1175 return stack.Initialize.Add(&validateOpCreateCidrCollection{}, middleware.After) 1176 } 1177 1178 func addOpCreateHealthCheckValidationMiddleware(stack *middleware.Stack) error { 1179 return stack.Initialize.Add(&validateOpCreateHealthCheck{}, middleware.After) 1180 } 1181 1182 func addOpCreateHostedZoneValidationMiddleware(stack *middleware.Stack) error { 1183 return stack.Initialize.Add(&validateOpCreateHostedZone{}, middleware.After) 1184 } 1185 1186 func addOpCreateKeySigningKeyValidationMiddleware(stack *middleware.Stack) error { 1187 return stack.Initialize.Add(&validateOpCreateKeySigningKey{}, middleware.After) 1188 } 1189 1190 func addOpCreateQueryLoggingConfigValidationMiddleware(stack *middleware.Stack) error { 1191 return stack.Initialize.Add(&validateOpCreateQueryLoggingConfig{}, middleware.After) 1192 } 1193 1194 func addOpCreateReusableDelegationSetValidationMiddleware(stack *middleware.Stack) error { 1195 return stack.Initialize.Add(&validateOpCreateReusableDelegationSet{}, middleware.After) 1196 } 1197 1198 func addOpCreateTrafficPolicyValidationMiddleware(stack *middleware.Stack) error { 1199 return stack.Initialize.Add(&validateOpCreateTrafficPolicy{}, middleware.After) 1200 } 1201 1202 func addOpCreateTrafficPolicyInstanceValidationMiddleware(stack *middleware.Stack) error { 1203 return stack.Initialize.Add(&validateOpCreateTrafficPolicyInstance{}, middleware.After) 1204 } 1205 1206 func addOpCreateTrafficPolicyVersionValidationMiddleware(stack *middleware.Stack) error { 1207 return stack.Initialize.Add(&validateOpCreateTrafficPolicyVersion{}, middleware.After) 1208 } 1209 1210 func addOpCreateVPCAssociationAuthorizationValidationMiddleware(stack *middleware.Stack) error { 1211 return stack.Initialize.Add(&validateOpCreateVPCAssociationAuthorization{}, middleware.After) 1212 } 1213 1214 func addOpDeactivateKeySigningKeyValidationMiddleware(stack *middleware.Stack) error { 1215 return stack.Initialize.Add(&validateOpDeactivateKeySigningKey{}, middleware.After) 1216 } 1217 1218 func addOpDeleteCidrCollectionValidationMiddleware(stack *middleware.Stack) error { 1219 return stack.Initialize.Add(&validateOpDeleteCidrCollection{}, middleware.After) 1220 } 1221 1222 func addOpDeleteHealthCheckValidationMiddleware(stack *middleware.Stack) error { 1223 return stack.Initialize.Add(&validateOpDeleteHealthCheck{}, middleware.After) 1224 } 1225 1226 func addOpDeleteHostedZoneValidationMiddleware(stack *middleware.Stack) error { 1227 return stack.Initialize.Add(&validateOpDeleteHostedZone{}, middleware.After) 1228 } 1229 1230 func addOpDeleteKeySigningKeyValidationMiddleware(stack *middleware.Stack) error { 1231 return stack.Initialize.Add(&validateOpDeleteKeySigningKey{}, middleware.After) 1232 } 1233 1234 func addOpDeleteQueryLoggingConfigValidationMiddleware(stack *middleware.Stack) error { 1235 return stack.Initialize.Add(&validateOpDeleteQueryLoggingConfig{}, middleware.After) 1236 } 1237 1238 func addOpDeleteReusableDelegationSetValidationMiddleware(stack *middleware.Stack) error { 1239 return stack.Initialize.Add(&validateOpDeleteReusableDelegationSet{}, middleware.After) 1240 } 1241 1242 func addOpDeleteTrafficPolicyValidationMiddleware(stack *middleware.Stack) error { 1243 return stack.Initialize.Add(&validateOpDeleteTrafficPolicy{}, middleware.After) 1244 } 1245 1246 func addOpDeleteTrafficPolicyInstanceValidationMiddleware(stack *middleware.Stack) error { 1247 return stack.Initialize.Add(&validateOpDeleteTrafficPolicyInstance{}, middleware.After) 1248 } 1249 1250 func addOpDeleteVPCAssociationAuthorizationValidationMiddleware(stack *middleware.Stack) error { 1251 return stack.Initialize.Add(&validateOpDeleteVPCAssociationAuthorization{}, middleware.After) 1252 } 1253 1254 func addOpDisableHostedZoneDNSSECValidationMiddleware(stack *middleware.Stack) error { 1255 return stack.Initialize.Add(&validateOpDisableHostedZoneDNSSEC{}, middleware.After) 1256 } 1257 1258 func addOpDisassociateVPCFromHostedZoneValidationMiddleware(stack *middleware.Stack) error { 1259 return stack.Initialize.Add(&validateOpDisassociateVPCFromHostedZone{}, middleware.After) 1260 } 1261 1262 func addOpEnableHostedZoneDNSSECValidationMiddleware(stack *middleware.Stack) error { 1263 return stack.Initialize.Add(&validateOpEnableHostedZoneDNSSEC{}, middleware.After) 1264 } 1265 1266 func addOpGetAccountLimitValidationMiddleware(stack *middleware.Stack) error { 1267 return stack.Initialize.Add(&validateOpGetAccountLimit{}, middleware.After) 1268 } 1269 1270 func addOpGetChangeValidationMiddleware(stack *middleware.Stack) error { 1271 return stack.Initialize.Add(&validateOpGetChange{}, middleware.After) 1272 } 1273 1274 func addOpGetDNSSECValidationMiddleware(stack *middleware.Stack) error { 1275 return stack.Initialize.Add(&validateOpGetDNSSEC{}, middleware.After) 1276 } 1277 1278 func addOpGetHealthCheckValidationMiddleware(stack *middleware.Stack) error { 1279 return stack.Initialize.Add(&validateOpGetHealthCheck{}, middleware.After) 1280 } 1281 1282 func addOpGetHealthCheckLastFailureReasonValidationMiddleware(stack *middleware.Stack) error { 1283 return stack.Initialize.Add(&validateOpGetHealthCheckLastFailureReason{}, middleware.After) 1284 } 1285 1286 func addOpGetHealthCheckStatusValidationMiddleware(stack *middleware.Stack) error { 1287 return stack.Initialize.Add(&validateOpGetHealthCheckStatus{}, middleware.After) 1288 } 1289 1290 func addOpGetHostedZoneValidationMiddleware(stack *middleware.Stack) error { 1291 return stack.Initialize.Add(&validateOpGetHostedZone{}, middleware.After) 1292 } 1293 1294 func addOpGetHostedZoneLimitValidationMiddleware(stack *middleware.Stack) error { 1295 return stack.Initialize.Add(&validateOpGetHostedZoneLimit{}, middleware.After) 1296 } 1297 1298 func addOpGetQueryLoggingConfigValidationMiddleware(stack *middleware.Stack) error { 1299 return stack.Initialize.Add(&validateOpGetQueryLoggingConfig{}, middleware.After) 1300 } 1301 1302 func addOpGetReusableDelegationSetValidationMiddleware(stack *middleware.Stack) error { 1303 return stack.Initialize.Add(&validateOpGetReusableDelegationSet{}, middleware.After) 1304 } 1305 1306 func addOpGetReusableDelegationSetLimitValidationMiddleware(stack *middleware.Stack) error { 1307 return stack.Initialize.Add(&validateOpGetReusableDelegationSetLimit{}, middleware.After) 1308 } 1309 1310 func addOpGetTrafficPolicyValidationMiddleware(stack *middleware.Stack) error { 1311 return stack.Initialize.Add(&validateOpGetTrafficPolicy{}, middleware.After) 1312 } 1313 1314 func addOpGetTrafficPolicyInstanceValidationMiddleware(stack *middleware.Stack) error { 1315 return stack.Initialize.Add(&validateOpGetTrafficPolicyInstance{}, middleware.After) 1316 } 1317 1318 func addOpListCidrBlocksValidationMiddleware(stack *middleware.Stack) error { 1319 return stack.Initialize.Add(&validateOpListCidrBlocks{}, middleware.After) 1320 } 1321 1322 func addOpListCidrLocationsValidationMiddleware(stack *middleware.Stack) error { 1323 return stack.Initialize.Add(&validateOpListCidrLocations{}, middleware.After) 1324 } 1325 1326 func addOpListHostedZonesByVPCValidationMiddleware(stack *middleware.Stack) error { 1327 return stack.Initialize.Add(&validateOpListHostedZonesByVPC{}, middleware.After) 1328 } 1329 1330 func addOpListResourceRecordSetsValidationMiddleware(stack *middleware.Stack) error { 1331 return stack.Initialize.Add(&validateOpListResourceRecordSets{}, middleware.After) 1332 } 1333 1334 func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 1335 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 1336 } 1337 1338 func addOpListTagsForResourcesValidationMiddleware(stack *middleware.Stack) error { 1339 return stack.Initialize.Add(&validateOpListTagsForResources{}, middleware.After) 1340 } 1341 1342 func addOpListTrafficPolicyInstancesByHostedZoneValidationMiddleware(stack *middleware.Stack) error { 1343 return stack.Initialize.Add(&validateOpListTrafficPolicyInstancesByHostedZone{}, middleware.After) 1344 } 1345 1346 func addOpListTrafficPolicyInstancesByPolicyValidationMiddleware(stack *middleware.Stack) error { 1347 return stack.Initialize.Add(&validateOpListTrafficPolicyInstancesByPolicy{}, middleware.After) 1348 } 1349 1350 func addOpListTrafficPolicyVersionsValidationMiddleware(stack *middleware.Stack) error { 1351 return stack.Initialize.Add(&validateOpListTrafficPolicyVersions{}, middleware.After) 1352 } 1353 1354 func addOpListVPCAssociationAuthorizationsValidationMiddleware(stack *middleware.Stack) error { 1355 return stack.Initialize.Add(&validateOpListVPCAssociationAuthorizations{}, middleware.After) 1356 } 1357 1358 func addOpTestDNSAnswerValidationMiddleware(stack *middleware.Stack) error { 1359 return stack.Initialize.Add(&validateOpTestDNSAnswer{}, middleware.After) 1360 } 1361 1362 func addOpUpdateHealthCheckValidationMiddleware(stack *middleware.Stack) error { 1363 return stack.Initialize.Add(&validateOpUpdateHealthCheck{}, middleware.After) 1364 } 1365 1366 func addOpUpdateHostedZoneCommentValidationMiddleware(stack *middleware.Stack) error { 1367 return stack.Initialize.Add(&validateOpUpdateHostedZoneComment{}, middleware.After) 1368 } 1369 1370 func addOpUpdateHostedZoneFeaturesValidationMiddleware(stack *middleware.Stack) error { 1371 return stack.Initialize.Add(&validateOpUpdateHostedZoneFeatures{}, middleware.After) 1372 } 1373 1374 func addOpUpdateTrafficPolicyCommentValidationMiddleware(stack *middleware.Stack) error { 1375 return stack.Initialize.Add(&validateOpUpdateTrafficPolicyComment{}, middleware.After) 1376 } 1377 1378 func addOpUpdateTrafficPolicyInstanceValidationMiddleware(stack *middleware.Stack) error { 1379 return stack.Initialize.Add(&validateOpUpdateTrafficPolicyInstance{}, middleware.After) 1380 } 1381 1382 func validateAlarmIdentifier(v *types.AlarmIdentifier) error { 1383 if v == nil { 1384 return nil 1385 } 1386 invalidParams := smithy.InvalidParamsError{Context: "AlarmIdentifier"} 1387 if len(v.Region) == 0 { 1388 invalidParams.Add(smithy.NewErrParamRequired("Region")) 1389 } 1390 if v.Name == nil { 1391 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1392 } 1393 if invalidParams.Len() > 0 { 1394 return invalidParams 1395 } else { 1396 return nil 1397 } 1398 } 1399 1400 func validateAliasTarget(v *types.AliasTarget) error { 1401 if v == nil { 1402 return nil 1403 } 1404 invalidParams := smithy.InvalidParamsError{Context: "AliasTarget"} 1405 if v.HostedZoneId == nil { 1406 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1407 } 1408 if v.DNSName == nil { 1409 invalidParams.Add(smithy.NewErrParamRequired("DNSName")) 1410 } 1411 if invalidParams.Len() > 0 { 1412 return invalidParams 1413 } else { 1414 return nil 1415 } 1416 } 1417 1418 func validateChange(v *types.Change) error { 1419 if v == nil { 1420 return nil 1421 } 1422 invalidParams := smithy.InvalidParamsError{Context: "Change"} 1423 if len(v.Action) == 0 { 1424 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1425 } 1426 if v.ResourceRecordSet == nil { 1427 invalidParams.Add(smithy.NewErrParamRequired("ResourceRecordSet")) 1428 } else if v.ResourceRecordSet != nil { 1429 if err := validateResourceRecordSet(v.ResourceRecordSet); err != nil { 1430 invalidParams.AddNested("ResourceRecordSet", err.(smithy.InvalidParamsError)) 1431 } 1432 } 1433 if invalidParams.Len() > 0 { 1434 return invalidParams 1435 } else { 1436 return nil 1437 } 1438 } 1439 1440 func validateChangeBatch(v *types.ChangeBatch) error { 1441 if v == nil { 1442 return nil 1443 } 1444 invalidParams := smithy.InvalidParamsError{Context: "ChangeBatch"} 1445 if v.Changes == nil { 1446 invalidParams.Add(smithy.NewErrParamRequired("Changes")) 1447 } else if v.Changes != nil { 1448 if err := validateChanges(v.Changes); err != nil { 1449 invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError)) 1450 } 1451 } 1452 if invalidParams.Len() > 0 { 1453 return invalidParams 1454 } else { 1455 return nil 1456 } 1457 } 1458 1459 func validateChanges(v []types.Change) error { 1460 if v == nil { 1461 return nil 1462 } 1463 invalidParams := smithy.InvalidParamsError{Context: "Changes"} 1464 for i := range v { 1465 if err := validateChange(&v[i]); err != nil { 1466 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1467 } 1468 } 1469 if invalidParams.Len() > 0 { 1470 return invalidParams 1471 } else { 1472 return nil 1473 } 1474 } 1475 1476 func validateCidrCollectionChange(v *types.CidrCollectionChange) error { 1477 if v == nil { 1478 return nil 1479 } 1480 invalidParams := smithy.InvalidParamsError{Context: "CidrCollectionChange"} 1481 if v.LocationName == nil { 1482 invalidParams.Add(smithy.NewErrParamRequired("LocationName")) 1483 } 1484 if len(v.Action) == 0 { 1485 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1486 } 1487 if v.CidrList == nil { 1488 invalidParams.Add(smithy.NewErrParamRequired("CidrList")) 1489 } 1490 if invalidParams.Len() > 0 { 1491 return invalidParams 1492 } else { 1493 return nil 1494 } 1495 } 1496 1497 func validateCidrCollectionChanges(v []types.CidrCollectionChange) error { 1498 if v == nil { 1499 return nil 1500 } 1501 invalidParams := smithy.InvalidParamsError{Context: "CidrCollectionChanges"} 1502 for i := range v { 1503 if err := validateCidrCollectionChange(&v[i]); err != nil { 1504 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1505 } 1506 } 1507 if invalidParams.Len() > 0 { 1508 return invalidParams 1509 } else { 1510 return nil 1511 } 1512 } 1513 1514 func validateCidrRoutingConfig(v *types.CidrRoutingConfig) error { 1515 if v == nil { 1516 return nil 1517 } 1518 invalidParams := smithy.InvalidParamsError{Context: "CidrRoutingConfig"} 1519 if v.CollectionId == nil { 1520 invalidParams.Add(smithy.NewErrParamRequired("CollectionId")) 1521 } 1522 if v.LocationName == nil { 1523 invalidParams.Add(smithy.NewErrParamRequired("LocationName")) 1524 } 1525 if invalidParams.Len() > 0 { 1526 return invalidParams 1527 } else { 1528 return nil 1529 } 1530 } 1531 1532 func validateCoordinates(v *types.Coordinates) error { 1533 if v == nil { 1534 return nil 1535 } 1536 invalidParams := smithy.InvalidParamsError{Context: "Coordinates"} 1537 if v.Latitude == nil { 1538 invalidParams.Add(smithy.NewErrParamRequired("Latitude")) 1539 } 1540 if v.Longitude == nil { 1541 invalidParams.Add(smithy.NewErrParamRequired("Longitude")) 1542 } 1543 if invalidParams.Len() > 0 { 1544 return invalidParams 1545 } else { 1546 return nil 1547 } 1548 } 1549 1550 func validateGeoProximityLocation(v *types.GeoProximityLocation) error { 1551 if v == nil { 1552 return nil 1553 } 1554 invalidParams := smithy.InvalidParamsError{Context: "GeoProximityLocation"} 1555 if v.Coordinates != nil { 1556 if err := validateCoordinates(v.Coordinates); err != nil { 1557 invalidParams.AddNested("Coordinates", err.(smithy.InvalidParamsError)) 1558 } 1559 } 1560 if invalidParams.Len() > 0 { 1561 return invalidParams 1562 } else { 1563 return nil 1564 } 1565 } 1566 1567 func validateHealthCheckConfig(v *types.HealthCheckConfig) error { 1568 if v == nil { 1569 return nil 1570 } 1571 invalidParams := smithy.InvalidParamsError{Context: "HealthCheckConfig"} 1572 if len(v.Type) == 0 { 1573 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1574 } 1575 if v.AlarmIdentifier != nil { 1576 if err := validateAlarmIdentifier(v.AlarmIdentifier); err != nil { 1577 invalidParams.AddNested("AlarmIdentifier", err.(smithy.InvalidParamsError)) 1578 } 1579 } 1580 if invalidParams.Len() > 0 { 1581 return invalidParams 1582 } else { 1583 return nil 1584 } 1585 } 1586 1587 func validateResourceRecord(v *types.ResourceRecord) error { 1588 if v == nil { 1589 return nil 1590 } 1591 invalidParams := smithy.InvalidParamsError{Context: "ResourceRecord"} 1592 if v.Value == nil { 1593 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1594 } 1595 if invalidParams.Len() > 0 { 1596 return invalidParams 1597 } else { 1598 return nil 1599 } 1600 } 1601 1602 func validateResourceRecords(v []types.ResourceRecord) error { 1603 if v == nil { 1604 return nil 1605 } 1606 invalidParams := smithy.InvalidParamsError{Context: "ResourceRecords"} 1607 for i := range v { 1608 if err := validateResourceRecord(&v[i]); err != nil { 1609 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1610 } 1611 } 1612 if invalidParams.Len() > 0 { 1613 return invalidParams 1614 } else { 1615 return nil 1616 } 1617 } 1618 1619 func validateResourceRecordSet(v *types.ResourceRecordSet) error { 1620 if v == nil { 1621 return nil 1622 } 1623 invalidParams := smithy.InvalidParamsError{Context: "ResourceRecordSet"} 1624 if v.Name == nil { 1625 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1626 } 1627 if len(v.Type) == 0 { 1628 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1629 } 1630 if v.ResourceRecords != nil { 1631 if err := validateResourceRecords(v.ResourceRecords); err != nil { 1632 invalidParams.AddNested("ResourceRecords", err.(smithy.InvalidParamsError)) 1633 } 1634 } 1635 if v.AliasTarget != nil { 1636 if err := validateAliasTarget(v.AliasTarget); err != nil { 1637 invalidParams.AddNested("AliasTarget", err.(smithy.InvalidParamsError)) 1638 } 1639 } 1640 if v.CidrRoutingConfig != nil { 1641 if err := validateCidrRoutingConfig(v.CidrRoutingConfig); err != nil { 1642 invalidParams.AddNested("CidrRoutingConfig", err.(smithy.InvalidParamsError)) 1643 } 1644 } 1645 if v.GeoProximityLocation != nil { 1646 if err := validateGeoProximityLocation(v.GeoProximityLocation); err != nil { 1647 invalidParams.AddNested("GeoProximityLocation", err.(smithy.InvalidParamsError)) 1648 } 1649 } 1650 if invalidParams.Len() > 0 { 1651 return invalidParams 1652 } else { 1653 return nil 1654 } 1655 } 1656 1657 func validateOpActivateKeySigningKeyInput(v *ActivateKeySigningKeyInput) error { 1658 if v == nil { 1659 return nil 1660 } 1661 invalidParams := smithy.InvalidParamsError{Context: "ActivateKeySigningKeyInput"} 1662 if v.HostedZoneId == nil { 1663 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1664 } 1665 if v.Name == nil { 1666 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1667 } 1668 if invalidParams.Len() > 0 { 1669 return invalidParams 1670 } else { 1671 return nil 1672 } 1673 } 1674 1675 func validateOpAssociateVPCWithHostedZoneInput(v *AssociateVPCWithHostedZoneInput) error { 1676 if v == nil { 1677 return nil 1678 } 1679 invalidParams := smithy.InvalidParamsError{Context: "AssociateVPCWithHostedZoneInput"} 1680 if v.HostedZoneId == nil { 1681 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1682 } 1683 if v.VPC == nil { 1684 invalidParams.Add(smithy.NewErrParamRequired("VPC")) 1685 } 1686 if invalidParams.Len() > 0 { 1687 return invalidParams 1688 } else { 1689 return nil 1690 } 1691 } 1692 1693 func validateOpChangeCidrCollectionInput(v *ChangeCidrCollectionInput) error { 1694 if v == nil { 1695 return nil 1696 } 1697 invalidParams := smithy.InvalidParamsError{Context: "ChangeCidrCollectionInput"} 1698 if v.Id == nil { 1699 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1700 } 1701 if v.Changes == nil { 1702 invalidParams.Add(smithy.NewErrParamRequired("Changes")) 1703 } else if v.Changes != nil { 1704 if err := validateCidrCollectionChanges(v.Changes); err != nil { 1705 invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError)) 1706 } 1707 } 1708 if invalidParams.Len() > 0 { 1709 return invalidParams 1710 } else { 1711 return nil 1712 } 1713 } 1714 1715 func validateOpChangeResourceRecordSetsInput(v *ChangeResourceRecordSetsInput) error { 1716 if v == nil { 1717 return nil 1718 } 1719 invalidParams := smithy.InvalidParamsError{Context: "ChangeResourceRecordSetsInput"} 1720 if v.HostedZoneId == nil { 1721 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1722 } 1723 if v.ChangeBatch == nil { 1724 invalidParams.Add(smithy.NewErrParamRequired("ChangeBatch")) 1725 } else if v.ChangeBatch != nil { 1726 if err := validateChangeBatch(v.ChangeBatch); err != nil { 1727 invalidParams.AddNested("ChangeBatch", err.(smithy.InvalidParamsError)) 1728 } 1729 } 1730 if invalidParams.Len() > 0 { 1731 return invalidParams 1732 } else { 1733 return nil 1734 } 1735 } 1736 1737 func validateOpChangeTagsForResourceInput(v *ChangeTagsForResourceInput) error { 1738 if v == nil { 1739 return nil 1740 } 1741 invalidParams := smithy.InvalidParamsError{Context: "ChangeTagsForResourceInput"} 1742 if len(v.ResourceType) == 0 { 1743 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 1744 } 1745 if v.ResourceId == nil { 1746 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1747 } 1748 if invalidParams.Len() > 0 { 1749 return invalidParams 1750 } else { 1751 return nil 1752 } 1753 } 1754 1755 func validateOpCreateCidrCollectionInput(v *CreateCidrCollectionInput) error { 1756 if v == nil { 1757 return nil 1758 } 1759 invalidParams := smithy.InvalidParamsError{Context: "CreateCidrCollectionInput"} 1760 if v.Name == nil { 1761 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1762 } 1763 if v.CallerReference == nil { 1764 invalidParams.Add(smithy.NewErrParamRequired("CallerReference")) 1765 } 1766 if invalidParams.Len() > 0 { 1767 return invalidParams 1768 } else { 1769 return nil 1770 } 1771 } 1772 1773 func validateOpCreateHealthCheckInput(v *CreateHealthCheckInput) error { 1774 if v == nil { 1775 return nil 1776 } 1777 invalidParams := smithy.InvalidParamsError{Context: "CreateHealthCheckInput"} 1778 if v.CallerReference == nil { 1779 invalidParams.Add(smithy.NewErrParamRequired("CallerReference")) 1780 } 1781 if v.HealthCheckConfig == nil { 1782 invalidParams.Add(smithy.NewErrParamRequired("HealthCheckConfig")) 1783 } else if v.HealthCheckConfig != nil { 1784 if err := validateHealthCheckConfig(v.HealthCheckConfig); err != nil { 1785 invalidParams.AddNested("HealthCheckConfig", err.(smithy.InvalidParamsError)) 1786 } 1787 } 1788 if invalidParams.Len() > 0 { 1789 return invalidParams 1790 } else { 1791 return nil 1792 } 1793 } 1794 1795 func validateOpCreateHostedZoneInput(v *CreateHostedZoneInput) error { 1796 if v == nil { 1797 return nil 1798 } 1799 invalidParams := smithy.InvalidParamsError{Context: "CreateHostedZoneInput"} 1800 if v.Name == nil { 1801 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1802 } 1803 if v.CallerReference == nil { 1804 invalidParams.Add(smithy.NewErrParamRequired("CallerReference")) 1805 } 1806 if invalidParams.Len() > 0 { 1807 return invalidParams 1808 } else { 1809 return nil 1810 } 1811 } 1812 1813 func validateOpCreateKeySigningKeyInput(v *CreateKeySigningKeyInput) error { 1814 if v == nil { 1815 return nil 1816 } 1817 invalidParams := smithy.InvalidParamsError{Context: "CreateKeySigningKeyInput"} 1818 if v.CallerReference == nil { 1819 invalidParams.Add(smithy.NewErrParamRequired("CallerReference")) 1820 } 1821 if v.HostedZoneId == nil { 1822 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1823 } 1824 if v.KeyManagementServiceArn == nil { 1825 invalidParams.Add(smithy.NewErrParamRequired("KeyManagementServiceArn")) 1826 } 1827 if v.Name == nil { 1828 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1829 } 1830 if v.Status == nil { 1831 invalidParams.Add(smithy.NewErrParamRequired("Status")) 1832 } 1833 if invalidParams.Len() > 0 { 1834 return invalidParams 1835 } else { 1836 return nil 1837 } 1838 } 1839 1840 func validateOpCreateQueryLoggingConfigInput(v *CreateQueryLoggingConfigInput) error { 1841 if v == nil { 1842 return nil 1843 } 1844 invalidParams := smithy.InvalidParamsError{Context: "CreateQueryLoggingConfigInput"} 1845 if v.HostedZoneId == nil { 1846 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1847 } 1848 if v.CloudWatchLogsLogGroupArn == nil { 1849 invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogsLogGroupArn")) 1850 } 1851 if invalidParams.Len() > 0 { 1852 return invalidParams 1853 } else { 1854 return nil 1855 } 1856 } 1857 1858 func validateOpCreateReusableDelegationSetInput(v *CreateReusableDelegationSetInput) error { 1859 if v == nil { 1860 return nil 1861 } 1862 invalidParams := smithy.InvalidParamsError{Context: "CreateReusableDelegationSetInput"} 1863 if v.CallerReference == nil { 1864 invalidParams.Add(smithy.NewErrParamRequired("CallerReference")) 1865 } 1866 if invalidParams.Len() > 0 { 1867 return invalidParams 1868 } else { 1869 return nil 1870 } 1871 } 1872 1873 func validateOpCreateTrafficPolicyInput(v *CreateTrafficPolicyInput) error { 1874 if v == nil { 1875 return nil 1876 } 1877 invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyInput"} 1878 if v.Name == nil { 1879 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1880 } 1881 if v.Document == nil { 1882 invalidParams.Add(smithy.NewErrParamRequired("Document")) 1883 } 1884 if invalidParams.Len() > 0 { 1885 return invalidParams 1886 } else { 1887 return nil 1888 } 1889 } 1890 1891 func validateOpCreateTrafficPolicyInstanceInput(v *CreateTrafficPolicyInstanceInput) error { 1892 if v == nil { 1893 return nil 1894 } 1895 invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyInstanceInput"} 1896 if v.HostedZoneId == nil { 1897 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1898 } 1899 if v.Name == nil { 1900 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1901 } 1902 if v.TTL == nil { 1903 invalidParams.Add(smithy.NewErrParamRequired("TTL")) 1904 } 1905 if v.TrafficPolicyId == nil { 1906 invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId")) 1907 } 1908 if v.TrafficPolicyVersion == nil { 1909 invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion")) 1910 } 1911 if invalidParams.Len() > 0 { 1912 return invalidParams 1913 } else { 1914 return nil 1915 } 1916 } 1917 1918 func validateOpCreateTrafficPolicyVersionInput(v *CreateTrafficPolicyVersionInput) error { 1919 if v == nil { 1920 return nil 1921 } 1922 invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyVersionInput"} 1923 if v.Id == nil { 1924 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1925 } 1926 if v.Document == nil { 1927 invalidParams.Add(smithy.NewErrParamRequired("Document")) 1928 } 1929 if invalidParams.Len() > 0 { 1930 return invalidParams 1931 } else { 1932 return nil 1933 } 1934 } 1935 1936 func validateOpCreateVPCAssociationAuthorizationInput(v *CreateVPCAssociationAuthorizationInput) error { 1937 if v == nil { 1938 return nil 1939 } 1940 invalidParams := smithy.InvalidParamsError{Context: "CreateVPCAssociationAuthorizationInput"} 1941 if v.HostedZoneId == nil { 1942 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1943 } 1944 if v.VPC == nil { 1945 invalidParams.Add(smithy.NewErrParamRequired("VPC")) 1946 } 1947 if invalidParams.Len() > 0 { 1948 return invalidParams 1949 } else { 1950 return nil 1951 } 1952 } 1953 1954 func validateOpDeactivateKeySigningKeyInput(v *DeactivateKeySigningKeyInput) error { 1955 if v == nil { 1956 return nil 1957 } 1958 invalidParams := smithy.InvalidParamsError{Context: "DeactivateKeySigningKeyInput"} 1959 if v.HostedZoneId == nil { 1960 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 1961 } 1962 if v.Name == nil { 1963 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1964 } 1965 if invalidParams.Len() > 0 { 1966 return invalidParams 1967 } else { 1968 return nil 1969 } 1970 } 1971 1972 func validateOpDeleteCidrCollectionInput(v *DeleteCidrCollectionInput) error { 1973 if v == nil { 1974 return nil 1975 } 1976 invalidParams := smithy.InvalidParamsError{Context: "DeleteCidrCollectionInput"} 1977 if v.Id == nil { 1978 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1979 } 1980 if invalidParams.Len() > 0 { 1981 return invalidParams 1982 } else { 1983 return nil 1984 } 1985 } 1986 1987 func validateOpDeleteHealthCheckInput(v *DeleteHealthCheckInput) error { 1988 if v == nil { 1989 return nil 1990 } 1991 invalidParams := smithy.InvalidParamsError{Context: "DeleteHealthCheckInput"} 1992 if v.HealthCheckId == nil { 1993 invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId")) 1994 } 1995 if invalidParams.Len() > 0 { 1996 return invalidParams 1997 } else { 1998 return nil 1999 } 2000 } 2001 2002 func validateOpDeleteHostedZoneInput(v *DeleteHostedZoneInput) error { 2003 if v == nil { 2004 return nil 2005 } 2006 invalidParams := smithy.InvalidParamsError{Context: "DeleteHostedZoneInput"} 2007 if v.Id == nil { 2008 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2009 } 2010 if invalidParams.Len() > 0 { 2011 return invalidParams 2012 } else { 2013 return nil 2014 } 2015 } 2016 2017 func validateOpDeleteKeySigningKeyInput(v *DeleteKeySigningKeyInput) error { 2018 if v == nil { 2019 return nil 2020 } 2021 invalidParams := smithy.InvalidParamsError{Context: "DeleteKeySigningKeyInput"} 2022 if v.HostedZoneId == nil { 2023 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2024 } 2025 if v.Name == nil { 2026 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2027 } 2028 if invalidParams.Len() > 0 { 2029 return invalidParams 2030 } else { 2031 return nil 2032 } 2033 } 2034 2035 func validateOpDeleteQueryLoggingConfigInput(v *DeleteQueryLoggingConfigInput) error { 2036 if v == nil { 2037 return nil 2038 } 2039 invalidParams := smithy.InvalidParamsError{Context: "DeleteQueryLoggingConfigInput"} 2040 if v.Id == nil { 2041 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2042 } 2043 if invalidParams.Len() > 0 { 2044 return invalidParams 2045 } else { 2046 return nil 2047 } 2048 } 2049 2050 func validateOpDeleteReusableDelegationSetInput(v *DeleteReusableDelegationSetInput) error { 2051 if v == nil { 2052 return nil 2053 } 2054 invalidParams := smithy.InvalidParamsError{Context: "DeleteReusableDelegationSetInput"} 2055 if v.Id == nil { 2056 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2057 } 2058 if invalidParams.Len() > 0 { 2059 return invalidParams 2060 } else { 2061 return nil 2062 } 2063 } 2064 2065 func validateOpDeleteTrafficPolicyInput(v *DeleteTrafficPolicyInput) error { 2066 if v == nil { 2067 return nil 2068 } 2069 invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficPolicyInput"} 2070 if v.Id == nil { 2071 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2072 } 2073 if v.Version == nil { 2074 invalidParams.Add(smithy.NewErrParamRequired("Version")) 2075 } 2076 if invalidParams.Len() > 0 { 2077 return invalidParams 2078 } else { 2079 return nil 2080 } 2081 } 2082 2083 func validateOpDeleteTrafficPolicyInstanceInput(v *DeleteTrafficPolicyInstanceInput) error { 2084 if v == nil { 2085 return nil 2086 } 2087 invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficPolicyInstanceInput"} 2088 if v.Id == nil { 2089 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2090 } 2091 if invalidParams.Len() > 0 { 2092 return invalidParams 2093 } else { 2094 return nil 2095 } 2096 } 2097 2098 func validateOpDeleteVPCAssociationAuthorizationInput(v *DeleteVPCAssociationAuthorizationInput) error { 2099 if v == nil { 2100 return nil 2101 } 2102 invalidParams := smithy.InvalidParamsError{Context: "DeleteVPCAssociationAuthorizationInput"} 2103 if v.HostedZoneId == nil { 2104 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2105 } 2106 if v.VPC == nil { 2107 invalidParams.Add(smithy.NewErrParamRequired("VPC")) 2108 } 2109 if invalidParams.Len() > 0 { 2110 return invalidParams 2111 } else { 2112 return nil 2113 } 2114 } 2115 2116 func validateOpDisableHostedZoneDNSSECInput(v *DisableHostedZoneDNSSECInput) error { 2117 if v == nil { 2118 return nil 2119 } 2120 invalidParams := smithy.InvalidParamsError{Context: "DisableHostedZoneDNSSECInput"} 2121 if v.HostedZoneId == nil { 2122 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2123 } 2124 if invalidParams.Len() > 0 { 2125 return invalidParams 2126 } else { 2127 return nil 2128 } 2129 } 2130 2131 func validateOpDisassociateVPCFromHostedZoneInput(v *DisassociateVPCFromHostedZoneInput) error { 2132 if v == nil { 2133 return nil 2134 } 2135 invalidParams := smithy.InvalidParamsError{Context: "DisassociateVPCFromHostedZoneInput"} 2136 if v.HostedZoneId == nil { 2137 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2138 } 2139 if v.VPC == nil { 2140 invalidParams.Add(smithy.NewErrParamRequired("VPC")) 2141 } 2142 if invalidParams.Len() > 0 { 2143 return invalidParams 2144 } else { 2145 return nil 2146 } 2147 } 2148 2149 func validateOpEnableHostedZoneDNSSECInput(v *EnableHostedZoneDNSSECInput) error { 2150 if v == nil { 2151 return nil 2152 } 2153 invalidParams := smithy.InvalidParamsError{Context: "EnableHostedZoneDNSSECInput"} 2154 if v.HostedZoneId == nil { 2155 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2156 } 2157 if invalidParams.Len() > 0 { 2158 return invalidParams 2159 } else { 2160 return nil 2161 } 2162 } 2163 2164 func validateOpGetAccountLimitInput(v *GetAccountLimitInput) error { 2165 if v == nil { 2166 return nil 2167 } 2168 invalidParams := smithy.InvalidParamsError{Context: "GetAccountLimitInput"} 2169 if len(v.Type) == 0 { 2170 invalidParams.Add(smithy.NewErrParamRequired("Type")) 2171 } 2172 if invalidParams.Len() > 0 { 2173 return invalidParams 2174 } else { 2175 return nil 2176 } 2177 } 2178 2179 func validateOpGetChangeInput(v *GetChangeInput) error { 2180 if v == nil { 2181 return nil 2182 } 2183 invalidParams := smithy.InvalidParamsError{Context: "GetChangeInput"} 2184 if v.Id == nil { 2185 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2186 } 2187 if invalidParams.Len() > 0 { 2188 return invalidParams 2189 } else { 2190 return nil 2191 } 2192 } 2193 2194 func validateOpGetDNSSECInput(v *GetDNSSECInput) error { 2195 if v == nil { 2196 return nil 2197 } 2198 invalidParams := smithy.InvalidParamsError{Context: "GetDNSSECInput"} 2199 if v.HostedZoneId == nil { 2200 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2201 } 2202 if invalidParams.Len() > 0 { 2203 return invalidParams 2204 } else { 2205 return nil 2206 } 2207 } 2208 2209 func validateOpGetHealthCheckInput(v *GetHealthCheckInput) error { 2210 if v == nil { 2211 return nil 2212 } 2213 invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckInput"} 2214 if v.HealthCheckId == nil { 2215 invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId")) 2216 } 2217 if invalidParams.Len() > 0 { 2218 return invalidParams 2219 } else { 2220 return nil 2221 } 2222 } 2223 2224 func validateOpGetHealthCheckLastFailureReasonInput(v *GetHealthCheckLastFailureReasonInput) error { 2225 if v == nil { 2226 return nil 2227 } 2228 invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckLastFailureReasonInput"} 2229 if v.HealthCheckId == nil { 2230 invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId")) 2231 } 2232 if invalidParams.Len() > 0 { 2233 return invalidParams 2234 } else { 2235 return nil 2236 } 2237 } 2238 2239 func validateOpGetHealthCheckStatusInput(v *GetHealthCheckStatusInput) error { 2240 if v == nil { 2241 return nil 2242 } 2243 invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckStatusInput"} 2244 if v.HealthCheckId == nil { 2245 invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId")) 2246 } 2247 if invalidParams.Len() > 0 { 2248 return invalidParams 2249 } else { 2250 return nil 2251 } 2252 } 2253 2254 func validateOpGetHostedZoneInput(v *GetHostedZoneInput) error { 2255 if v == nil { 2256 return nil 2257 } 2258 invalidParams := smithy.InvalidParamsError{Context: "GetHostedZoneInput"} 2259 if v.Id == nil { 2260 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2261 } 2262 if invalidParams.Len() > 0 { 2263 return invalidParams 2264 } else { 2265 return nil 2266 } 2267 } 2268 2269 func validateOpGetHostedZoneLimitInput(v *GetHostedZoneLimitInput) error { 2270 if v == nil { 2271 return nil 2272 } 2273 invalidParams := smithy.InvalidParamsError{Context: "GetHostedZoneLimitInput"} 2274 if len(v.Type) == 0 { 2275 invalidParams.Add(smithy.NewErrParamRequired("Type")) 2276 } 2277 if v.HostedZoneId == nil { 2278 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2279 } 2280 if invalidParams.Len() > 0 { 2281 return invalidParams 2282 } else { 2283 return nil 2284 } 2285 } 2286 2287 func validateOpGetQueryLoggingConfigInput(v *GetQueryLoggingConfigInput) error { 2288 if v == nil { 2289 return nil 2290 } 2291 invalidParams := smithy.InvalidParamsError{Context: "GetQueryLoggingConfigInput"} 2292 if v.Id == nil { 2293 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2294 } 2295 if invalidParams.Len() > 0 { 2296 return invalidParams 2297 } else { 2298 return nil 2299 } 2300 } 2301 2302 func validateOpGetReusableDelegationSetInput(v *GetReusableDelegationSetInput) error { 2303 if v == nil { 2304 return nil 2305 } 2306 invalidParams := smithy.InvalidParamsError{Context: "GetReusableDelegationSetInput"} 2307 if v.Id == nil { 2308 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2309 } 2310 if invalidParams.Len() > 0 { 2311 return invalidParams 2312 } else { 2313 return nil 2314 } 2315 } 2316 2317 func validateOpGetReusableDelegationSetLimitInput(v *GetReusableDelegationSetLimitInput) error { 2318 if v == nil { 2319 return nil 2320 } 2321 invalidParams := smithy.InvalidParamsError{Context: "GetReusableDelegationSetLimitInput"} 2322 if len(v.Type) == 0 { 2323 invalidParams.Add(smithy.NewErrParamRequired("Type")) 2324 } 2325 if v.DelegationSetId == nil { 2326 invalidParams.Add(smithy.NewErrParamRequired("DelegationSetId")) 2327 } 2328 if invalidParams.Len() > 0 { 2329 return invalidParams 2330 } else { 2331 return nil 2332 } 2333 } 2334 2335 func validateOpGetTrafficPolicyInput(v *GetTrafficPolicyInput) error { 2336 if v == nil { 2337 return nil 2338 } 2339 invalidParams := smithy.InvalidParamsError{Context: "GetTrafficPolicyInput"} 2340 if v.Id == nil { 2341 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2342 } 2343 if v.Version == nil { 2344 invalidParams.Add(smithy.NewErrParamRequired("Version")) 2345 } 2346 if invalidParams.Len() > 0 { 2347 return invalidParams 2348 } else { 2349 return nil 2350 } 2351 } 2352 2353 func validateOpGetTrafficPolicyInstanceInput(v *GetTrafficPolicyInstanceInput) error { 2354 if v == nil { 2355 return nil 2356 } 2357 invalidParams := smithy.InvalidParamsError{Context: "GetTrafficPolicyInstanceInput"} 2358 if v.Id == nil { 2359 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2360 } 2361 if invalidParams.Len() > 0 { 2362 return invalidParams 2363 } else { 2364 return nil 2365 } 2366 } 2367 2368 func validateOpListCidrBlocksInput(v *ListCidrBlocksInput) error { 2369 if v == nil { 2370 return nil 2371 } 2372 invalidParams := smithy.InvalidParamsError{Context: "ListCidrBlocksInput"} 2373 if v.CollectionId == nil { 2374 invalidParams.Add(smithy.NewErrParamRequired("CollectionId")) 2375 } 2376 if invalidParams.Len() > 0 { 2377 return invalidParams 2378 } else { 2379 return nil 2380 } 2381 } 2382 2383 func validateOpListCidrLocationsInput(v *ListCidrLocationsInput) error { 2384 if v == nil { 2385 return nil 2386 } 2387 invalidParams := smithy.InvalidParamsError{Context: "ListCidrLocationsInput"} 2388 if v.CollectionId == nil { 2389 invalidParams.Add(smithy.NewErrParamRequired("CollectionId")) 2390 } 2391 if invalidParams.Len() > 0 { 2392 return invalidParams 2393 } else { 2394 return nil 2395 } 2396 } 2397 2398 func validateOpListHostedZonesByVPCInput(v *ListHostedZonesByVPCInput) error { 2399 if v == nil { 2400 return nil 2401 } 2402 invalidParams := smithy.InvalidParamsError{Context: "ListHostedZonesByVPCInput"} 2403 if v.VPCId == nil { 2404 invalidParams.Add(smithy.NewErrParamRequired("VPCId")) 2405 } 2406 if len(v.VPCRegion) == 0 { 2407 invalidParams.Add(smithy.NewErrParamRequired("VPCRegion")) 2408 } 2409 if invalidParams.Len() > 0 { 2410 return invalidParams 2411 } else { 2412 return nil 2413 } 2414 } 2415 2416 func validateOpListResourceRecordSetsInput(v *ListResourceRecordSetsInput) error { 2417 if v == nil { 2418 return nil 2419 } 2420 invalidParams := smithy.InvalidParamsError{Context: "ListResourceRecordSetsInput"} 2421 if v.HostedZoneId == nil { 2422 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2423 } 2424 if invalidParams.Len() > 0 { 2425 return invalidParams 2426 } else { 2427 return nil 2428 } 2429 } 2430 2431 func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 2432 if v == nil { 2433 return nil 2434 } 2435 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 2436 if len(v.ResourceType) == 0 { 2437 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 2438 } 2439 if v.ResourceId == nil { 2440 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 2441 } 2442 if invalidParams.Len() > 0 { 2443 return invalidParams 2444 } else { 2445 return nil 2446 } 2447 } 2448 2449 func validateOpListTagsForResourcesInput(v *ListTagsForResourcesInput) error { 2450 if v == nil { 2451 return nil 2452 } 2453 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourcesInput"} 2454 if len(v.ResourceType) == 0 { 2455 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 2456 } 2457 if v.ResourceIds == nil { 2458 invalidParams.Add(smithy.NewErrParamRequired("ResourceIds")) 2459 } 2460 if invalidParams.Len() > 0 { 2461 return invalidParams 2462 } else { 2463 return nil 2464 } 2465 } 2466 2467 func validateOpListTrafficPolicyInstancesByHostedZoneInput(v *ListTrafficPolicyInstancesByHostedZoneInput) error { 2468 if v == nil { 2469 return nil 2470 } 2471 invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyInstancesByHostedZoneInput"} 2472 if v.HostedZoneId == nil { 2473 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2474 } 2475 if invalidParams.Len() > 0 { 2476 return invalidParams 2477 } else { 2478 return nil 2479 } 2480 } 2481 2482 func validateOpListTrafficPolicyInstancesByPolicyInput(v *ListTrafficPolicyInstancesByPolicyInput) error { 2483 if v == nil { 2484 return nil 2485 } 2486 invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyInstancesByPolicyInput"} 2487 if v.TrafficPolicyId == nil { 2488 invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId")) 2489 } 2490 if v.TrafficPolicyVersion == nil { 2491 invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion")) 2492 } 2493 if invalidParams.Len() > 0 { 2494 return invalidParams 2495 } else { 2496 return nil 2497 } 2498 } 2499 2500 func validateOpListTrafficPolicyVersionsInput(v *ListTrafficPolicyVersionsInput) error { 2501 if v == nil { 2502 return nil 2503 } 2504 invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyVersionsInput"} 2505 if v.Id == nil { 2506 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2507 } 2508 if invalidParams.Len() > 0 { 2509 return invalidParams 2510 } else { 2511 return nil 2512 } 2513 } 2514 2515 func validateOpListVPCAssociationAuthorizationsInput(v *ListVPCAssociationAuthorizationsInput) error { 2516 if v == nil { 2517 return nil 2518 } 2519 invalidParams := smithy.InvalidParamsError{Context: "ListVPCAssociationAuthorizationsInput"} 2520 if v.HostedZoneId == nil { 2521 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2522 } 2523 if invalidParams.Len() > 0 { 2524 return invalidParams 2525 } else { 2526 return nil 2527 } 2528 } 2529 2530 func validateOpTestDNSAnswerInput(v *TestDNSAnswerInput) error { 2531 if v == nil { 2532 return nil 2533 } 2534 invalidParams := smithy.InvalidParamsError{Context: "TestDNSAnswerInput"} 2535 if v.HostedZoneId == nil { 2536 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2537 } 2538 if v.RecordName == nil { 2539 invalidParams.Add(smithy.NewErrParamRequired("RecordName")) 2540 } 2541 if len(v.RecordType) == 0 { 2542 invalidParams.Add(smithy.NewErrParamRequired("RecordType")) 2543 } 2544 if invalidParams.Len() > 0 { 2545 return invalidParams 2546 } else { 2547 return nil 2548 } 2549 } 2550 2551 func validateOpUpdateHealthCheckInput(v *UpdateHealthCheckInput) error { 2552 if v == nil { 2553 return nil 2554 } 2555 invalidParams := smithy.InvalidParamsError{Context: "UpdateHealthCheckInput"} 2556 if v.HealthCheckId == nil { 2557 invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId")) 2558 } 2559 if v.AlarmIdentifier != nil { 2560 if err := validateAlarmIdentifier(v.AlarmIdentifier); err != nil { 2561 invalidParams.AddNested("AlarmIdentifier", err.(smithy.InvalidParamsError)) 2562 } 2563 } 2564 if invalidParams.Len() > 0 { 2565 return invalidParams 2566 } else { 2567 return nil 2568 } 2569 } 2570 2571 func validateOpUpdateHostedZoneCommentInput(v *UpdateHostedZoneCommentInput) error { 2572 if v == nil { 2573 return nil 2574 } 2575 invalidParams := smithy.InvalidParamsError{Context: "UpdateHostedZoneCommentInput"} 2576 if v.Id == nil { 2577 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2578 } 2579 if invalidParams.Len() > 0 { 2580 return invalidParams 2581 } else { 2582 return nil 2583 } 2584 } 2585 2586 func validateOpUpdateHostedZoneFeaturesInput(v *UpdateHostedZoneFeaturesInput) error { 2587 if v == nil { 2588 return nil 2589 } 2590 invalidParams := smithy.InvalidParamsError{Context: "UpdateHostedZoneFeaturesInput"} 2591 if v.HostedZoneId == nil { 2592 invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId")) 2593 } 2594 if invalidParams.Len() > 0 { 2595 return invalidParams 2596 } else { 2597 return nil 2598 } 2599 } 2600 2601 func validateOpUpdateTrafficPolicyCommentInput(v *UpdateTrafficPolicyCommentInput) error { 2602 if v == nil { 2603 return nil 2604 } 2605 invalidParams := smithy.InvalidParamsError{Context: "UpdateTrafficPolicyCommentInput"} 2606 if v.Id == nil { 2607 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2608 } 2609 if v.Version == nil { 2610 invalidParams.Add(smithy.NewErrParamRequired("Version")) 2611 } 2612 if v.Comment == nil { 2613 invalidParams.Add(smithy.NewErrParamRequired("Comment")) 2614 } 2615 if invalidParams.Len() > 0 { 2616 return invalidParams 2617 } else { 2618 return nil 2619 } 2620 } 2621 2622 func validateOpUpdateTrafficPolicyInstanceInput(v *UpdateTrafficPolicyInstanceInput) error { 2623 if v == nil { 2624 return nil 2625 } 2626 invalidParams := smithy.InvalidParamsError{Context: "UpdateTrafficPolicyInstanceInput"} 2627 if v.Id == nil { 2628 invalidParams.Add(smithy.NewErrParamRequired("Id")) 2629 } 2630 if v.TTL == nil { 2631 invalidParams.Add(smithy.NewErrParamRequired("TTL")) 2632 } 2633 if v.TrafficPolicyId == nil { 2634 invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId")) 2635 } 2636 if v.TrafficPolicyVersion == nil { 2637 invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion")) 2638 } 2639 if invalidParams.Len() > 0 { 2640 return invalidParams 2641 } else { 2642 return nil 2643 } 2644 }