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