src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

validators.go (79378B)

      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 validateCoordinates(v *types.Coordinates) error {
   1508 	if v == nil {
   1509 		return nil
   1510 	}
   1511 	invalidParams := smithy.InvalidParamsError{Context: "Coordinates"}
   1512 	if v.Latitude == nil {
   1513 		invalidParams.Add(smithy.NewErrParamRequired("Latitude"))
   1514 	}
   1515 	if v.Longitude == nil {
   1516 		invalidParams.Add(smithy.NewErrParamRequired("Longitude"))
   1517 	}
   1518 	if invalidParams.Len() > 0 {
   1519 		return invalidParams
   1520 	} else {
   1521 		return nil
   1522 	}
   1523 }
   1524 
   1525 func validateGeoProximityLocation(v *types.GeoProximityLocation) error {
   1526 	if v == nil {
   1527 		return nil
   1528 	}
   1529 	invalidParams := smithy.InvalidParamsError{Context: "GeoProximityLocation"}
   1530 	if v.Coordinates != nil {
   1531 		if err := validateCoordinates(v.Coordinates); err != nil {
   1532 			invalidParams.AddNested("Coordinates", err.(smithy.InvalidParamsError))
   1533 		}
   1534 	}
   1535 	if invalidParams.Len() > 0 {
   1536 		return invalidParams
   1537 	} else {
   1538 		return nil
   1539 	}
   1540 }
   1541 
   1542 func validateHealthCheckConfig(v *types.HealthCheckConfig) error {
   1543 	if v == nil {
   1544 		return nil
   1545 	}
   1546 	invalidParams := smithy.InvalidParamsError{Context: "HealthCheckConfig"}
   1547 	if len(v.Type) == 0 {
   1548 		invalidParams.Add(smithy.NewErrParamRequired("Type"))
   1549 	}
   1550 	if v.AlarmIdentifier != nil {
   1551 		if err := validateAlarmIdentifier(v.AlarmIdentifier); err != nil {
   1552 			invalidParams.AddNested("AlarmIdentifier", err.(smithy.InvalidParamsError))
   1553 		}
   1554 	}
   1555 	if invalidParams.Len() > 0 {
   1556 		return invalidParams
   1557 	} else {
   1558 		return nil
   1559 	}
   1560 }
   1561 
   1562 func validateResourceRecord(v *types.ResourceRecord) error {
   1563 	if v == nil {
   1564 		return nil
   1565 	}
   1566 	invalidParams := smithy.InvalidParamsError{Context: "ResourceRecord"}
   1567 	if v.Value == nil {
   1568 		invalidParams.Add(smithy.NewErrParamRequired("Value"))
   1569 	}
   1570 	if invalidParams.Len() > 0 {
   1571 		return invalidParams
   1572 	} else {
   1573 		return nil
   1574 	}
   1575 }
   1576 
   1577 func validateResourceRecords(v []types.ResourceRecord) error {
   1578 	if v == nil {
   1579 		return nil
   1580 	}
   1581 	invalidParams := smithy.InvalidParamsError{Context: "ResourceRecords"}
   1582 	for i := range v {
   1583 		if err := validateResourceRecord(&v[i]); err != nil {
   1584 			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
   1585 		}
   1586 	}
   1587 	if invalidParams.Len() > 0 {
   1588 		return invalidParams
   1589 	} else {
   1590 		return nil
   1591 	}
   1592 }
   1593 
   1594 func validateResourceRecordSet(v *types.ResourceRecordSet) error {
   1595 	if v == nil {
   1596 		return nil
   1597 	}
   1598 	invalidParams := smithy.InvalidParamsError{Context: "ResourceRecordSet"}
   1599 	if v.Name == nil {
   1600 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
   1601 	}
   1602 	if len(v.Type) == 0 {
   1603 		invalidParams.Add(smithy.NewErrParamRequired("Type"))
   1604 	}
   1605 	if v.ResourceRecords != nil {
   1606 		if err := validateResourceRecords(v.ResourceRecords); err != nil {
   1607 			invalidParams.AddNested("ResourceRecords", err.(smithy.InvalidParamsError))
   1608 		}
   1609 	}
   1610 	if v.AliasTarget != nil {
   1611 		if err := validateAliasTarget(v.AliasTarget); err != nil {
   1612 			invalidParams.AddNested("AliasTarget", err.(smithy.InvalidParamsError))
   1613 		}
   1614 	}
   1615 	if v.CidrRoutingConfig != nil {
   1616 		if err := validateCidrRoutingConfig(v.CidrRoutingConfig); err != nil {
   1617 			invalidParams.AddNested("CidrRoutingConfig", err.(smithy.InvalidParamsError))
   1618 		}
   1619 	}
   1620 	if v.GeoProximityLocation != nil {
   1621 		if err := validateGeoProximityLocation(v.GeoProximityLocation); err != nil {
   1622 			invalidParams.AddNested("GeoProximityLocation", err.(smithy.InvalidParamsError))
   1623 		}
   1624 	}
   1625 	if invalidParams.Len() > 0 {
   1626 		return invalidParams
   1627 	} else {
   1628 		return nil
   1629 	}
   1630 }
   1631 
   1632 func validateOpActivateKeySigningKeyInput(v *ActivateKeySigningKeyInput) error {
   1633 	if v == nil {
   1634 		return nil
   1635 	}
   1636 	invalidParams := smithy.InvalidParamsError{Context: "ActivateKeySigningKeyInput"}
   1637 	if v.HostedZoneId == nil {
   1638 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1639 	}
   1640 	if v.Name == nil {
   1641 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
   1642 	}
   1643 	if invalidParams.Len() > 0 {
   1644 		return invalidParams
   1645 	} else {
   1646 		return nil
   1647 	}
   1648 }
   1649 
   1650 func validateOpAssociateVPCWithHostedZoneInput(v *AssociateVPCWithHostedZoneInput) error {
   1651 	if v == nil {
   1652 		return nil
   1653 	}
   1654 	invalidParams := smithy.InvalidParamsError{Context: "AssociateVPCWithHostedZoneInput"}
   1655 	if v.HostedZoneId == nil {
   1656 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1657 	}
   1658 	if v.VPC == nil {
   1659 		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
   1660 	}
   1661 	if invalidParams.Len() > 0 {
   1662 		return invalidParams
   1663 	} else {
   1664 		return nil
   1665 	}
   1666 }
   1667 
   1668 func validateOpChangeCidrCollectionInput(v *ChangeCidrCollectionInput) error {
   1669 	if v == nil {
   1670 		return nil
   1671 	}
   1672 	invalidParams := smithy.InvalidParamsError{Context: "ChangeCidrCollectionInput"}
   1673 	if v.Id == nil {
   1674 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   1675 	}
   1676 	if v.Changes == nil {
   1677 		invalidParams.Add(smithy.NewErrParamRequired("Changes"))
   1678 	} else if v.Changes != nil {
   1679 		if err := validateCidrCollectionChanges(v.Changes); err != nil {
   1680 			invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError))
   1681 		}
   1682 	}
   1683 	if invalidParams.Len() > 0 {
   1684 		return invalidParams
   1685 	} else {
   1686 		return nil
   1687 	}
   1688 }
   1689 
   1690 func validateOpChangeResourceRecordSetsInput(v *ChangeResourceRecordSetsInput) error {
   1691 	if v == nil {
   1692 		return nil
   1693 	}
   1694 	invalidParams := smithy.InvalidParamsError{Context: "ChangeResourceRecordSetsInput"}
   1695 	if v.HostedZoneId == nil {
   1696 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1697 	}
   1698 	if v.ChangeBatch == nil {
   1699 		invalidParams.Add(smithy.NewErrParamRequired("ChangeBatch"))
   1700 	} else if v.ChangeBatch != nil {
   1701 		if err := validateChangeBatch(v.ChangeBatch); err != nil {
   1702 			invalidParams.AddNested("ChangeBatch", err.(smithy.InvalidParamsError))
   1703 		}
   1704 	}
   1705 	if invalidParams.Len() > 0 {
   1706 		return invalidParams
   1707 	} else {
   1708 		return nil
   1709 	}
   1710 }
   1711 
   1712 func validateOpChangeTagsForResourceInput(v *ChangeTagsForResourceInput) error {
   1713 	if v == nil {
   1714 		return nil
   1715 	}
   1716 	invalidParams := smithy.InvalidParamsError{Context: "ChangeTagsForResourceInput"}
   1717 	if len(v.ResourceType) == 0 {
   1718 		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
   1719 	}
   1720 	if v.ResourceId == nil {
   1721 		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
   1722 	}
   1723 	if invalidParams.Len() > 0 {
   1724 		return invalidParams
   1725 	} else {
   1726 		return nil
   1727 	}
   1728 }
   1729 
   1730 func validateOpCreateCidrCollectionInput(v *CreateCidrCollectionInput) error {
   1731 	if v == nil {
   1732 		return nil
   1733 	}
   1734 	invalidParams := smithy.InvalidParamsError{Context: "CreateCidrCollectionInput"}
   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 validateOpCreateHealthCheckInput(v *CreateHealthCheckInput) error {
   1749 	if v == nil {
   1750 		return nil
   1751 	}
   1752 	invalidParams := smithy.InvalidParamsError{Context: "CreateHealthCheckInput"}
   1753 	if v.CallerReference == nil {
   1754 		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
   1755 	}
   1756 	if v.HealthCheckConfig == nil {
   1757 		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckConfig"))
   1758 	} else if v.HealthCheckConfig != nil {
   1759 		if err := validateHealthCheckConfig(v.HealthCheckConfig); err != nil {
   1760 			invalidParams.AddNested("HealthCheckConfig", err.(smithy.InvalidParamsError))
   1761 		}
   1762 	}
   1763 	if invalidParams.Len() > 0 {
   1764 		return invalidParams
   1765 	} else {
   1766 		return nil
   1767 	}
   1768 }
   1769 
   1770 func validateOpCreateHostedZoneInput(v *CreateHostedZoneInput) error {
   1771 	if v == nil {
   1772 		return nil
   1773 	}
   1774 	invalidParams := smithy.InvalidParamsError{Context: "CreateHostedZoneInput"}
   1775 	if v.Name == nil {
   1776 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
   1777 	}
   1778 	if v.CallerReference == nil {
   1779 		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
   1780 	}
   1781 	if invalidParams.Len() > 0 {
   1782 		return invalidParams
   1783 	} else {
   1784 		return nil
   1785 	}
   1786 }
   1787 
   1788 func validateOpCreateKeySigningKeyInput(v *CreateKeySigningKeyInput) error {
   1789 	if v == nil {
   1790 		return nil
   1791 	}
   1792 	invalidParams := smithy.InvalidParamsError{Context: "CreateKeySigningKeyInput"}
   1793 	if v.CallerReference == nil {
   1794 		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
   1795 	}
   1796 	if v.HostedZoneId == nil {
   1797 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1798 	}
   1799 	if v.KeyManagementServiceArn == nil {
   1800 		invalidParams.Add(smithy.NewErrParamRequired("KeyManagementServiceArn"))
   1801 	}
   1802 	if v.Name == nil {
   1803 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
   1804 	}
   1805 	if v.Status == nil {
   1806 		invalidParams.Add(smithy.NewErrParamRequired("Status"))
   1807 	}
   1808 	if invalidParams.Len() > 0 {
   1809 		return invalidParams
   1810 	} else {
   1811 		return nil
   1812 	}
   1813 }
   1814 
   1815 func validateOpCreateQueryLoggingConfigInput(v *CreateQueryLoggingConfigInput) error {
   1816 	if v == nil {
   1817 		return nil
   1818 	}
   1819 	invalidParams := smithy.InvalidParamsError{Context: "CreateQueryLoggingConfigInput"}
   1820 	if v.HostedZoneId == nil {
   1821 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1822 	}
   1823 	if v.CloudWatchLogsLogGroupArn == nil {
   1824 		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogsLogGroupArn"))
   1825 	}
   1826 	if invalidParams.Len() > 0 {
   1827 		return invalidParams
   1828 	} else {
   1829 		return nil
   1830 	}
   1831 }
   1832 
   1833 func validateOpCreateReusableDelegationSetInput(v *CreateReusableDelegationSetInput) error {
   1834 	if v == nil {
   1835 		return nil
   1836 	}
   1837 	invalidParams := smithy.InvalidParamsError{Context: "CreateReusableDelegationSetInput"}
   1838 	if v.CallerReference == nil {
   1839 		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
   1840 	}
   1841 	if invalidParams.Len() > 0 {
   1842 		return invalidParams
   1843 	} else {
   1844 		return nil
   1845 	}
   1846 }
   1847 
   1848 func validateOpCreateTrafficPolicyInput(v *CreateTrafficPolicyInput) error {
   1849 	if v == nil {
   1850 		return nil
   1851 	}
   1852 	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyInput"}
   1853 	if v.Name == nil {
   1854 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
   1855 	}
   1856 	if v.Document == nil {
   1857 		invalidParams.Add(smithy.NewErrParamRequired("Document"))
   1858 	}
   1859 	if invalidParams.Len() > 0 {
   1860 		return invalidParams
   1861 	} else {
   1862 		return nil
   1863 	}
   1864 }
   1865 
   1866 func validateOpCreateTrafficPolicyInstanceInput(v *CreateTrafficPolicyInstanceInput) error {
   1867 	if v == nil {
   1868 		return nil
   1869 	}
   1870 	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyInstanceInput"}
   1871 	if v.HostedZoneId == nil {
   1872 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1873 	}
   1874 	if v.Name == nil {
   1875 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
   1876 	}
   1877 	if v.TTL == nil {
   1878 		invalidParams.Add(smithy.NewErrParamRequired("TTL"))
   1879 	}
   1880 	if v.TrafficPolicyId == nil {
   1881 		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
   1882 	}
   1883 	if v.TrafficPolicyVersion == nil {
   1884 		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
   1885 	}
   1886 	if invalidParams.Len() > 0 {
   1887 		return invalidParams
   1888 	} else {
   1889 		return nil
   1890 	}
   1891 }
   1892 
   1893 func validateOpCreateTrafficPolicyVersionInput(v *CreateTrafficPolicyVersionInput) error {
   1894 	if v == nil {
   1895 		return nil
   1896 	}
   1897 	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyVersionInput"}
   1898 	if v.Id == nil {
   1899 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   1900 	}
   1901 	if v.Document == nil {
   1902 		invalidParams.Add(smithy.NewErrParamRequired("Document"))
   1903 	}
   1904 	if invalidParams.Len() > 0 {
   1905 		return invalidParams
   1906 	} else {
   1907 		return nil
   1908 	}
   1909 }
   1910 
   1911 func validateOpCreateVPCAssociationAuthorizationInput(v *CreateVPCAssociationAuthorizationInput) error {
   1912 	if v == nil {
   1913 		return nil
   1914 	}
   1915 	invalidParams := smithy.InvalidParamsError{Context: "CreateVPCAssociationAuthorizationInput"}
   1916 	if v.HostedZoneId == nil {
   1917 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1918 	}
   1919 	if v.VPC == nil {
   1920 		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
   1921 	}
   1922 	if invalidParams.Len() > 0 {
   1923 		return invalidParams
   1924 	} else {
   1925 		return nil
   1926 	}
   1927 }
   1928 
   1929 func validateOpDeactivateKeySigningKeyInput(v *DeactivateKeySigningKeyInput) error {
   1930 	if v == nil {
   1931 		return nil
   1932 	}
   1933 	invalidParams := smithy.InvalidParamsError{Context: "DeactivateKeySigningKeyInput"}
   1934 	if v.HostedZoneId == nil {
   1935 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1936 	}
   1937 	if v.Name == nil {
   1938 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
   1939 	}
   1940 	if invalidParams.Len() > 0 {
   1941 		return invalidParams
   1942 	} else {
   1943 		return nil
   1944 	}
   1945 }
   1946 
   1947 func validateOpDeleteCidrCollectionInput(v *DeleteCidrCollectionInput) error {
   1948 	if v == nil {
   1949 		return nil
   1950 	}
   1951 	invalidParams := smithy.InvalidParamsError{Context: "DeleteCidrCollectionInput"}
   1952 	if v.Id == nil {
   1953 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   1954 	}
   1955 	if invalidParams.Len() > 0 {
   1956 		return invalidParams
   1957 	} else {
   1958 		return nil
   1959 	}
   1960 }
   1961 
   1962 func validateOpDeleteHealthCheckInput(v *DeleteHealthCheckInput) error {
   1963 	if v == nil {
   1964 		return nil
   1965 	}
   1966 	invalidParams := smithy.InvalidParamsError{Context: "DeleteHealthCheckInput"}
   1967 	if v.HealthCheckId == nil {
   1968 		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
   1969 	}
   1970 	if invalidParams.Len() > 0 {
   1971 		return invalidParams
   1972 	} else {
   1973 		return nil
   1974 	}
   1975 }
   1976 
   1977 func validateOpDeleteHostedZoneInput(v *DeleteHostedZoneInput) error {
   1978 	if v == nil {
   1979 		return nil
   1980 	}
   1981 	invalidParams := smithy.InvalidParamsError{Context: "DeleteHostedZoneInput"}
   1982 	if v.Id == nil {
   1983 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   1984 	}
   1985 	if invalidParams.Len() > 0 {
   1986 		return invalidParams
   1987 	} else {
   1988 		return nil
   1989 	}
   1990 }
   1991 
   1992 func validateOpDeleteKeySigningKeyInput(v *DeleteKeySigningKeyInput) error {
   1993 	if v == nil {
   1994 		return nil
   1995 	}
   1996 	invalidParams := smithy.InvalidParamsError{Context: "DeleteKeySigningKeyInput"}
   1997 	if v.HostedZoneId == nil {
   1998 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   1999 	}
   2000 	if v.Name == nil {
   2001 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
   2002 	}
   2003 	if invalidParams.Len() > 0 {
   2004 		return invalidParams
   2005 	} else {
   2006 		return nil
   2007 	}
   2008 }
   2009 
   2010 func validateOpDeleteQueryLoggingConfigInput(v *DeleteQueryLoggingConfigInput) error {
   2011 	if v == nil {
   2012 		return nil
   2013 	}
   2014 	invalidParams := smithy.InvalidParamsError{Context: "DeleteQueryLoggingConfigInput"}
   2015 	if v.Id == nil {
   2016 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2017 	}
   2018 	if invalidParams.Len() > 0 {
   2019 		return invalidParams
   2020 	} else {
   2021 		return nil
   2022 	}
   2023 }
   2024 
   2025 func validateOpDeleteReusableDelegationSetInput(v *DeleteReusableDelegationSetInput) error {
   2026 	if v == nil {
   2027 		return nil
   2028 	}
   2029 	invalidParams := smithy.InvalidParamsError{Context: "DeleteReusableDelegationSetInput"}
   2030 	if v.Id == nil {
   2031 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2032 	}
   2033 	if invalidParams.Len() > 0 {
   2034 		return invalidParams
   2035 	} else {
   2036 		return nil
   2037 	}
   2038 }
   2039 
   2040 func validateOpDeleteTrafficPolicyInput(v *DeleteTrafficPolicyInput) error {
   2041 	if v == nil {
   2042 		return nil
   2043 	}
   2044 	invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficPolicyInput"}
   2045 	if v.Id == nil {
   2046 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2047 	}
   2048 	if v.Version == nil {
   2049 		invalidParams.Add(smithy.NewErrParamRequired("Version"))
   2050 	}
   2051 	if invalidParams.Len() > 0 {
   2052 		return invalidParams
   2053 	} else {
   2054 		return nil
   2055 	}
   2056 }
   2057 
   2058 func validateOpDeleteTrafficPolicyInstanceInput(v *DeleteTrafficPolicyInstanceInput) error {
   2059 	if v == nil {
   2060 		return nil
   2061 	}
   2062 	invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficPolicyInstanceInput"}
   2063 	if v.Id == nil {
   2064 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2065 	}
   2066 	if invalidParams.Len() > 0 {
   2067 		return invalidParams
   2068 	} else {
   2069 		return nil
   2070 	}
   2071 }
   2072 
   2073 func validateOpDeleteVPCAssociationAuthorizationInput(v *DeleteVPCAssociationAuthorizationInput) error {
   2074 	if v == nil {
   2075 		return nil
   2076 	}
   2077 	invalidParams := smithy.InvalidParamsError{Context: "DeleteVPCAssociationAuthorizationInput"}
   2078 	if v.HostedZoneId == nil {
   2079 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2080 	}
   2081 	if v.VPC == nil {
   2082 		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
   2083 	}
   2084 	if invalidParams.Len() > 0 {
   2085 		return invalidParams
   2086 	} else {
   2087 		return nil
   2088 	}
   2089 }
   2090 
   2091 func validateOpDisableHostedZoneDNSSECInput(v *DisableHostedZoneDNSSECInput) error {
   2092 	if v == nil {
   2093 		return nil
   2094 	}
   2095 	invalidParams := smithy.InvalidParamsError{Context: "DisableHostedZoneDNSSECInput"}
   2096 	if v.HostedZoneId == nil {
   2097 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2098 	}
   2099 	if invalidParams.Len() > 0 {
   2100 		return invalidParams
   2101 	} else {
   2102 		return nil
   2103 	}
   2104 }
   2105 
   2106 func validateOpDisassociateVPCFromHostedZoneInput(v *DisassociateVPCFromHostedZoneInput) error {
   2107 	if v == nil {
   2108 		return nil
   2109 	}
   2110 	invalidParams := smithy.InvalidParamsError{Context: "DisassociateVPCFromHostedZoneInput"}
   2111 	if v.HostedZoneId == nil {
   2112 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2113 	}
   2114 	if v.VPC == nil {
   2115 		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
   2116 	}
   2117 	if invalidParams.Len() > 0 {
   2118 		return invalidParams
   2119 	} else {
   2120 		return nil
   2121 	}
   2122 }
   2123 
   2124 func validateOpEnableHostedZoneDNSSECInput(v *EnableHostedZoneDNSSECInput) error {
   2125 	if v == nil {
   2126 		return nil
   2127 	}
   2128 	invalidParams := smithy.InvalidParamsError{Context: "EnableHostedZoneDNSSECInput"}
   2129 	if v.HostedZoneId == nil {
   2130 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2131 	}
   2132 	if invalidParams.Len() > 0 {
   2133 		return invalidParams
   2134 	} else {
   2135 		return nil
   2136 	}
   2137 }
   2138 
   2139 func validateOpGetAccountLimitInput(v *GetAccountLimitInput) error {
   2140 	if v == nil {
   2141 		return nil
   2142 	}
   2143 	invalidParams := smithy.InvalidParamsError{Context: "GetAccountLimitInput"}
   2144 	if len(v.Type) == 0 {
   2145 		invalidParams.Add(smithy.NewErrParamRequired("Type"))
   2146 	}
   2147 	if invalidParams.Len() > 0 {
   2148 		return invalidParams
   2149 	} else {
   2150 		return nil
   2151 	}
   2152 }
   2153 
   2154 func validateOpGetChangeInput(v *GetChangeInput) error {
   2155 	if v == nil {
   2156 		return nil
   2157 	}
   2158 	invalidParams := smithy.InvalidParamsError{Context: "GetChangeInput"}
   2159 	if v.Id == nil {
   2160 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2161 	}
   2162 	if invalidParams.Len() > 0 {
   2163 		return invalidParams
   2164 	} else {
   2165 		return nil
   2166 	}
   2167 }
   2168 
   2169 func validateOpGetDNSSECInput(v *GetDNSSECInput) error {
   2170 	if v == nil {
   2171 		return nil
   2172 	}
   2173 	invalidParams := smithy.InvalidParamsError{Context: "GetDNSSECInput"}
   2174 	if v.HostedZoneId == nil {
   2175 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2176 	}
   2177 	if invalidParams.Len() > 0 {
   2178 		return invalidParams
   2179 	} else {
   2180 		return nil
   2181 	}
   2182 }
   2183 
   2184 func validateOpGetHealthCheckInput(v *GetHealthCheckInput) error {
   2185 	if v == nil {
   2186 		return nil
   2187 	}
   2188 	invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckInput"}
   2189 	if v.HealthCheckId == nil {
   2190 		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
   2191 	}
   2192 	if invalidParams.Len() > 0 {
   2193 		return invalidParams
   2194 	} else {
   2195 		return nil
   2196 	}
   2197 }
   2198 
   2199 func validateOpGetHealthCheckLastFailureReasonInput(v *GetHealthCheckLastFailureReasonInput) error {
   2200 	if v == nil {
   2201 		return nil
   2202 	}
   2203 	invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckLastFailureReasonInput"}
   2204 	if v.HealthCheckId == nil {
   2205 		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
   2206 	}
   2207 	if invalidParams.Len() > 0 {
   2208 		return invalidParams
   2209 	} else {
   2210 		return nil
   2211 	}
   2212 }
   2213 
   2214 func validateOpGetHealthCheckStatusInput(v *GetHealthCheckStatusInput) error {
   2215 	if v == nil {
   2216 		return nil
   2217 	}
   2218 	invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckStatusInput"}
   2219 	if v.HealthCheckId == nil {
   2220 		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
   2221 	}
   2222 	if invalidParams.Len() > 0 {
   2223 		return invalidParams
   2224 	} else {
   2225 		return nil
   2226 	}
   2227 }
   2228 
   2229 func validateOpGetHostedZoneInput(v *GetHostedZoneInput) error {
   2230 	if v == nil {
   2231 		return nil
   2232 	}
   2233 	invalidParams := smithy.InvalidParamsError{Context: "GetHostedZoneInput"}
   2234 	if v.Id == nil {
   2235 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2236 	}
   2237 	if invalidParams.Len() > 0 {
   2238 		return invalidParams
   2239 	} else {
   2240 		return nil
   2241 	}
   2242 }
   2243 
   2244 func validateOpGetHostedZoneLimitInput(v *GetHostedZoneLimitInput) error {
   2245 	if v == nil {
   2246 		return nil
   2247 	}
   2248 	invalidParams := smithy.InvalidParamsError{Context: "GetHostedZoneLimitInput"}
   2249 	if len(v.Type) == 0 {
   2250 		invalidParams.Add(smithy.NewErrParamRequired("Type"))
   2251 	}
   2252 	if v.HostedZoneId == nil {
   2253 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2254 	}
   2255 	if invalidParams.Len() > 0 {
   2256 		return invalidParams
   2257 	} else {
   2258 		return nil
   2259 	}
   2260 }
   2261 
   2262 func validateOpGetQueryLoggingConfigInput(v *GetQueryLoggingConfigInput) error {
   2263 	if v == nil {
   2264 		return nil
   2265 	}
   2266 	invalidParams := smithy.InvalidParamsError{Context: "GetQueryLoggingConfigInput"}
   2267 	if v.Id == nil {
   2268 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2269 	}
   2270 	if invalidParams.Len() > 0 {
   2271 		return invalidParams
   2272 	} else {
   2273 		return nil
   2274 	}
   2275 }
   2276 
   2277 func validateOpGetReusableDelegationSetInput(v *GetReusableDelegationSetInput) error {
   2278 	if v == nil {
   2279 		return nil
   2280 	}
   2281 	invalidParams := smithy.InvalidParamsError{Context: "GetReusableDelegationSetInput"}
   2282 	if v.Id == nil {
   2283 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2284 	}
   2285 	if invalidParams.Len() > 0 {
   2286 		return invalidParams
   2287 	} else {
   2288 		return nil
   2289 	}
   2290 }
   2291 
   2292 func validateOpGetReusableDelegationSetLimitInput(v *GetReusableDelegationSetLimitInput) error {
   2293 	if v == nil {
   2294 		return nil
   2295 	}
   2296 	invalidParams := smithy.InvalidParamsError{Context: "GetReusableDelegationSetLimitInput"}
   2297 	if len(v.Type) == 0 {
   2298 		invalidParams.Add(smithy.NewErrParamRequired("Type"))
   2299 	}
   2300 	if v.DelegationSetId == nil {
   2301 		invalidParams.Add(smithy.NewErrParamRequired("DelegationSetId"))
   2302 	}
   2303 	if invalidParams.Len() > 0 {
   2304 		return invalidParams
   2305 	} else {
   2306 		return nil
   2307 	}
   2308 }
   2309 
   2310 func validateOpGetTrafficPolicyInput(v *GetTrafficPolicyInput) error {
   2311 	if v == nil {
   2312 		return nil
   2313 	}
   2314 	invalidParams := smithy.InvalidParamsError{Context: "GetTrafficPolicyInput"}
   2315 	if v.Id == nil {
   2316 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2317 	}
   2318 	if v.Version == nil {
   2319 		invalidParams.Add(smithy.NewErrParamRequired("Version"))
   2320 	}
   2321 	if invalidParams.Len() > 0 {
   2322 		return invalidParams
   2323 	} else {
   2324 		return nil
   2325 	}
   2326 }
   2327 
   2328 func validateOpGetTrafficPolicyInstanceInput(v *GetTrafficPolicyInstanceInput) error {
   2329 	if v == nil {
   2330 		return nil
   2331 	}
   2332 	invalidParams := smithy.InvalidParamsError{Context: "GetTrafficPolicyInstanceInput"}
   2333 	if v.Id == nil {
   2334 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2335 	}
   2336 	if invalidParams.Len() > 0 {
   2337 		return invalidParams
   2338 	} else {
   2339 		return nil
   2340 	}
   2341 }
   2342 
   2343 func validateOpListCidrBlocksInput(v *ListCidrBlocksInput) error {
   2344 	if v == nil {
   2345 		return nil
   2346 	}
   2347 	invalidParams := smithy.InvalidParamsError{Context: "ListCidrBlocksInput"}
   2348 	if v.CollectionId == nil {
   2349 		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
   2350 	}
   2351 	if invalidParams.Len() > 0 {
   2352 		return invalidParams
   2353 	} else {
   2354 		return nil
   2355 	}
   2356 }
   2357 
   2358 func validateOpListCidrLocationsInput(v *ListCidrLocationsInput) error {
   2359 	if v == nil {
   2360 		return nil
   2361 	}
   2362 	invalidParams := smithy.InvalidParamsError{Context: "ListCidrLocationsInput"}
   2363 	if v.CollectionId == nil {
   2364 		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
   2365 	}
   2366 	if invalidParams.Len() > 0 {
   2367 		return invalidParams
   2368 	} else {
   2369 		return nil
   2370 	}
   2371 }
   2372 
   2373 func validateOpListHostedZonesByVPCInput(v *ListHostedZonesByVPCInput) error {
   2374 	if v == nil {
   2375 		return nil
   2376 	}
   2377 	invalidParams := smithy.InvalidParamsError{Context: "ListHostedZonesByVPCInput"}
   2378 	if v.VPCId == nil {
   2379 		invalidParams.Add(smithy.NewErrParamRequired("VPCId"))
   2380 	}
   2381 	if len(v.VPCRegion) == 0 {
   2382 		invalidParams.Add(smithy.NewErrParamRequired("VPCRegion"))
   2383 	}
   2384 	if invalidParams.Len() > 0 {
   2385 		return invalidParams
   2386 	} else {
   2387 		return nil
   2388 	}
   2389 }
   2390 
   2391 func validateOpListResourceRecordSetsInput(v *ListResourceRecordSetsInput) error {
   2392 	if v == nil {
   2393 		return nil
   2394 	}
   2395 	invalidParams := smithy.InvalidParamsError{Context: "ListResourceRecordSetsInput"}
   2396 	if v.HostedZoneId == nil {
   2397 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2398 	}
   2399 	if invalidParams.Len() > 0 {
   2400 		return invalidParams
   2401 	} else {
   2402 		return nil
   2403 	}
   2404 }
   2405 
   2406 func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
   2407 	if v == nil {
   2408 		return nil
   2409 	}
   2410 	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
   2411 	if len(v.ResourceType) == 0 {
   2412 		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
   2413 	}
   2414 	if v.ResourceId == nil {
   2415 		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
   2416 	}
   2417 	if invalidParams.Len() > 0 {
   2418 		return invalidParams
   2419 	} else {
   2420 		return nil
   2421 	}
   2422 }
   2423 
   2424 func validateOpListTagsForResourcesInput(v *ListTagsForResourcesInput) error {
   2425 	if v == nil {
   2426 		return nil
   2427 	}
   2428 	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourcesInput"}
   2429 	if len(v.ResourceType) == 0 {
   2430 		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
   2431 	}
   2432 	if v.ResourceIds == nil {
   2433 		invalidParams.Add(smithy.NewErrParamRequired("ResourceIds"))
   2434 	}
   2435 	if invalidParams.Len() > 0 {
   2436 		return invalidParams
   2437 	} else {
   2438 		return nil
   2439 	}
   2440 }
   2441 
   2442 func validateOpListTrafficPolicyInstancesByHostedZoneInput(v *ListTrafficPolicyInstancesByHostedZoneInput) error {
   2443 	if v == nil {
   2444 		return nil
   2445 	}
   2446 	invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyInstancesByHostedZoneInput"}
   2447 	if v.HostedZoneId == nil {
   2448 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2449 	}
   2450 	if invalidParams.Len() > 0 {
   2451 		return invalidParams
   2452 	} else {
   2453 		return nil
   2454 	}
   2455 }
   2456 
   2457 func validateOpListTrafficPolicyInstancesByPolicyInput(v *ListTrafficPolicyInstancesByPolicyInput) error {
   2458 	if v == nil {
   2459 		return nil
   2460 	}
   2461 	invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyInstancesByPolicyInput"}
   2462 	if v.TrafficPolicyId == nil {
   2463 		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
   2464 	}
   2465 	if v.TrafficPolicyVersion == nil {
   2466 		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
   2467 	}
   2468 	if invalidParams.Len() > 0 {
   2469 		return invalidParams
   2470 	} else {
   2471 		return nil
   2472 	}
   2473 }
   2474 
   2475 func validateOpListTrafficPolicyVersionsInput(v *ListTrafficPolicyVersionsInput) error {
   2476 	if v == nil {
   2477 		return nil
   2478 	}
   2479 	invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyVersionsInput"}
   2480 	if v.Id == nil {
   2481 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2482 	}
   2483 	if invalidParams.Len() > 0 {
   2484 		return invalidParams
   2485 	} else {
   2486 		return nil
   2487 	}
   2488 }
   2489 
   2490 func validateOpListVPCAssociationAuthorizationsInput(v *ListVPCAssociationAuthorizationsInput) error {
   2491 	if v == nil {
   2492 		return nil
   2493 	}
   2494 	invalidParams := smithy.InvalidParamsError{Context: "ListVPCAssociationAuthorizationsInput"}
   2495 	if v.HostedZoneId == nil {
   2496 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2497 	}
   2498 	if invalidParams.Len() > 0 {
   2499 		return invalidParams
   2500 	} else {
   2501 		return nil
   2502 	}
   2503 }
   2504 
   2505 func validateOpTestDNSAnswerInput(v *TestDNSAnswerInput) error {
   2506 	if v == nil {
   2507 		return nil
   2508 	}
   2509 	invalidParams := smithy.InvalidParamsError{Context: "TestDNSAnswerInput"}
   2510 	if v.HostedZoneId == nil {
   2511 		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
   2512 	}
   2513 	if v.RecordName == nil {
   2514 		invalidParams.Add(smithy.NewErrParamRequired("RecordName"))
   2515 	}
   2516 	if len(v.RecordType) == 0 {
   2517 		invalidParams.Add(smithy.NewErrParamRequired("RecordType"))
   2518 	}
   2519 	if invalidParams.Len() > 0 {
   2520 		return invalidParams
   2521 	} else {
   2522 		return nil
   2523 	}
   2524 }
   2525 
   2526 func validateOpUpdateHealthCheckInput(v *UpdateHealthCheckInput) error {
   2527 	if v == nil {
   2528 		return nil
   2529 	}
   2530 	invalidParams := smithy.InvalidParamsError{Context: "UpdateHealthCheckInput"}
   2531 	if v.HealthCheckId == nil {
   2532 		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
   2533 	}
   2534 	if v.AlarmIdentifier != nil {
   2535 		if err := validateAlarmIdentifier(v.AlarmIdentifier); err != nil {
   2536 			invalidParams.AddNested("AlarmIdentifier", err.(smithy.InvalidParamsError))
   2537 		}
   2538 	}
   2539 	if invalidParams.Len() > 0 {
   2540 		return invalidParams
   2541 	} else {
   2542 		return nil
   2543 	}
   2544 }
   2545 
   2546 func validateOpUpdateHostedZoneCommentInput(v *UpdateHostedZoneCommentInput) error {
   2547 	if v == nil {
   2548 		return nil
   2549 	}
   2550 	invalidParams := smithy.InvalidParamsError{Context: "UpdateHostedZoneCommentInput"}
   2551 	if v.Id == nil {
   2552 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2553 	}
   2554 	if invalidParams.Len() > 0 {
   2555 		return invalidParams
   2556 	} else {
   2557 		return nil
   2558 	}
   2559 }
   2560 
   2561 func validateOpUpdateTrafficPolicyCommentInput(v *UpdateTrafficPolicyCommentInput) error {
   2562 	if v == nil {
   2563 		return nil
   2564 	}
   2565 	invalidParams := smithy.InvalidParamsError{Context: "UpdateTrafficPolicyCommentInput"}
   2566 	if v.Id == nil {
   2567 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2568 	}
   2569 	if v.Version == nil {
   2570 		invalidParams.Add(smithy.NewErrParamRequired("Version"))
   2571 	}
   2572 	if v.Comment == nil {
   2573 		invalidParams.Add(smithy.NewErrParamRequired("Comment"))
   2574 	}
   2575 	if invalidParams.Len() > 0 {
   2576 		return invalidParams
   2577 	} else {
   2578 		return nil
   2579 	}
   2580 }
   2581 
   2582 func validateOpUpdateTrafficPolicyInstanceInput(v *UpdateTrafficPolicyInstanceInput) error {
   2583 	if v == nil {
   2584 		return nil
   2585 	}
   2586 	invalidParams := smithy.InvalidParamsError{Context: "UpdateTrafficPolicyInstanceInput"}
   2587 	if v.Id == nil {
   2588 		invalidParams.Add(smithy.NewErrParamRequired("Id"))
   2589 	}
   2590 	if v.TTL == nil {
   2591 		invalidParams.Add(smithy.NewErrParamRequired("TTL"))
   2592 	}
   2593 	if v.TrafficPolicyId == nil {
   2594 		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
   2595 	}
   2596 	if v.TrafficPolicyVersion == nil {
   2597 		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
   2598 	}
   2599 	if invalidParams.Len() > 0 {
   2600 		return invalidParams
   2601 	} else {
   2602 		return nil
   2603 	}
   2604 }