validators.go raw

   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 validateOpUpdateHostedZoneFeatures struct {
1094  }
1095  
1096  func (*validateOpUpdateHostedZoneFeatures) ID() string {
1097  	return "OperationInputValidation"
1098  }
1099  
1100  func (m *validateOpUpdateHostedZoneFeatures) 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.(*UpdateHostedZoneFeaturesInput)
1104  	if !ok {
1105  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106  	}
1107  	if err := validateOpUpdateHostedZoneFeaturesInput(input); err != nil {
1108  		return out, metadata, err
1109  	}
1110  	return next.HandleInitialize(ctx, in)
1111  }
1112  
1113  type validateOpUpdateTrafficPolicyComment struct {
1114  }
1115  
1116  func (*validateOpUpdateTrafficPolicyComment) ID() string {
1117  	return "OperationInputValidation"
1118  }
1119  
1120  func (m *validateOpUpdateTrafficPolicyComment) 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.(*UpdateTrafficPolicyCommentInput)
1124  	if !ok {
1125  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126  	}
1127  	if err := validateOpUpdateTrafficPolicyCommentInput(input); err != nil {
1128  		return out, metadata, err
1129  	}
1130  	return next.HandleInitialize(ctx, in)
1131  }
1132  
1133  type validateOpUpdateTrafficPolicyInstance struct {
1134  }
1135  
1136  func (*validateOpUpdateTrafficPolicyInstance) ID() string {
1137  	return "OperationInputValidation"
1138  }
1139  
1140  func (m *validateOpUpdateTrafficPolicyInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142  ) {
1143  	input, ok := in.Parameters.(*UpdateTrafficPolicyInstanceInput)
1144  	if !ok {
1145  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146  	}
1147  	if err := validateOpUpdateTrafficPolicyInstanceInput(input); err != nil {
1148  		return out, metadata, err
1149  	}
1150  	return next.HandleInitialize(ctx, in)
1151  }
1152  
1153  func addOpActivateKeySigningKeyValidationMiddleware(stack *middleware.Stack) error {
1154  	return stack.Initialize.Add(&validateOpActivateKeySigningKey{}, middleware.After)
1155  }
1156  
1157  func addOpAssociateVPCWithHostedZoneValidationMiddleware(stack *middleware.Stack) error {
1158  	return stack.Initialize.Add(&validateOpAssociateVPCWithHostedZone{}, middleware.After)
1159  }
1160  
1161  func addOpChangeCidrCollectionValidationMiddleware(stack *middleware.Stack) error {
1162  	return stack.Initialize.Add(&validateOpChangeCidrCollection{}, middleware.After)
1163  }
1164  
1165  func addOpChangeResourceRecordSetsValidationMiddleware(stack *middleware.Stack) error {
1166  	return stack.Initialize.Add(&validateOpChangeResourceRecordSets{}, middleware.After)
1167  }
1168  
1169  func addOpChangeTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
1170  	return stack.Initialize.Add(&validateOpChangeTagsForResource{}, middleware.After)
1171  }
1172  
1173  func addOpCreateCidrCollectionValidationMiddleware(stack *middleware.Stack) error {
1174  	return stack.Initialize.Add(&validateOpCreateCidrCollection{}, middleware.After)
1175  }
1176  
1177  func addOpCreateHealthCheckValidationMiddleware(stack *middleware.Stack) error {
1178  	return stack.Initialize.Add(&validateOpCreateHealthCheck{}, middleware.After)
1179  }
1180  
1181  func addOpCreateHostedZoneValidationMiddleware(stack *middleware.Stack) error {
1182  	return stack.Initialize.Add(&validateOpCreateHostedZone{}, middleware.After)
1183  }
1184  
1185  func addOpCreateKeySigningKeyValidationMiddleware(stack *middleware.Stack) error {
1186  	return stack.Initialize.Add(&validateOpCreateKeySigningKey{}, middleware.After)
1187  }
1188  
1189  func addOpCreateQueryLoggingConfigValidationMiddleware(stack *middleware.Stack) error {
1190  	return stack.Initialize.Add(&validateOpCreateQueryLoggingConfig{}, middleware.After)
1191  }
1192  
1193  func addOpCreateReusableDelegationSetValidationMiddleware(stack *middleware.Stack) error {
1194  	return stack.Initialize.Add(&validateOpCreateReusableDelegationSet{}, middleware.After)
1195  }
1196  
1197  func addOpCreateTrafficPolicyValidationMiddleware(stack *middleware.Stack) error {
1198  	return stack.Initialize.Add(&validateOpCreateTrafficPolicy{}, middleware.After)
1199  }
1200  
1201  func addOpCreateTrafficPolicyInstanceValidationMiddleware(stack *middleware.Stack) error {
1202  	return stack.Initialize.Add(&validateOpCreateTrafficPolicyInstance{}, middleware.After)
1203  }
1204  
1205  func addOpCreateTrafficPolicyVersionValidationMiddleware(stack *middleware.Stack) error {
1206  	return stack.Initialize.Add(&validateOpCreateTrafficPolicyVersion{}, middleware.After)
1207  }
1208  
1209  func addOpCreateVPCAssociationAuthorizationValidationMiddleware(stack *middleware.Stack) error {
1210  	return stack.Initialize.Add(&validateOpCreateVPCAssociationAuthorization{}, middleware.After)
1211  }
1212  
1213  func addOpDeactivateKeySigningKeyValidationMiddleware(stack *middleware.Stack) error {
1214  	return stack.Initialize.Add(&validateOpDeactivateKeySigningKey{}, middleware.After)
1215  }
1216  
1217  func addOpDeleteCidrCollectionValidationMiddleware(stack *middleware.Stack) error {
1218  	return stack.Initialize.Add(&validateOpDeleteCidrCollection{}, middleware.After)
1219  }
1220  
1221  func addOpDeleteHealthCheckValidationMiddleware(stack *middleware.Stack) error {
1222  	return stack.Initialize.Add(&validateOpDeleteHealthCheck{}, middleware.After)
1223  }
1224  
1225  func addOpDeleteHostedZoneValidationMiddleware(stack *middleware.Stack) error {
1226  	return stack.Initialize.Add(&validateOpDeleteHostedZone{}, middleware.After)
1227  }
1228  
1229  func addOpDeleteKeySigningKeyValidationMiddleware(stack *middleware.Stack) error {
1230  	return stack.Initialize.Add(&validateOpDeleteKeySigningKey{}, middleware.After)
1231  }
1232  
1233  func addOpDeleteQueryLoggingConfigValidationMiddleware(stack *middleware.Stack) error {
1234  	return stack.Initialize.Add(&validateOpDeleteQueryLoggingConfig{}, middleware.After)
1235  }
1236  
1237  func addOpDeleteReusableDelegationSetValidationMiddleware(stack *middleware.Stack) error {
1238  	return stack.Initialize.Add(&validateOpDeleteReusableDelegationSet{}, middleware.After)
1239  }
1240  
1241  func addOpDeleteTrafficPolicyValidationMiddleware(stack *middleware.Stack) error {
1242  	return stack.Initialize.Add(&validateOpDeleteTrafficPolicy{}, middleware.After)
1243  }
1244  
1245  func addOpDeleteTrafficPolicyInstanceValidationMiddleware(stack *middleware.Stack) error {
1246  	return stack.Initialize.Add(&validateOpDeleteTrafficPolicyInstance{}, middleware.After)
1247  }
1248  
1249  func addOpDeleteVPCAssociationAuthorizationValidationMiddleware(stack *middleware.Stack) error {
1250  	return stack.Initialize.Add(&validateOpDeleteVPCAssociationAuthorization{}, middleware.After)
1251  }
1252  
1253  func addOpDisableHostedZoneDNSSECValidationMiddleware(stack *middleware.Stack) error {
1254  	return stack.Initialize.Add(&validateOpDisableHostedZoneDNSSEC{}, middleware.After)
1255  }
1256  
1257  func addOpDisassociateVPCFromHostedZoneValidationMiddleware(stack *middleware.Stack) error {
1258  	return stack.Initialize.Add(&validateOpDisassociateVPCFromHostedZone{}, middleware.After)
1259  }
1260  
1261  func addOpEnableHostedZoneDNSSECValidationMiddleware(stack *middleware.Stack) error {
1262  	return stack.Initialize.Add(&validateOpEnableHostedZoneDNSSEC{}, middleware.After)
1263  }
1264  
1265  func addOpGetAccountLimitValidationMiddleware(stack *middleware.Stack) error {
1266  	return stack.Initialize.Add(&validateOpGetAccountLimit{}, middleware.After)
1267  }
1268  
1269  func addOpGetChangeValidationMiddleware(stack *middleware.Stack) error {
1270  	return stack.Initialize.Add(&validateOpGetChange{}, middleware.After)
1271  }
1272  
1273  func addOpGetDNSSECValidationMiddleware(stack *middleware.Stack) error {
1274  	return stack.Initialize.Add(&validateOpGetDNSSEC{}, middleware.After)
1275  }
1276  
1277  func addOpGetHealthCheckValidationMiddleware(stack *middleware.Stack) error {
1278  	return stack.Initialize.Add(&validateOpGetHealthCheck{}, middleware.After)
1279  }
1280  
1281  func addOpGetHealthCheckLastFailureReasonValidationMiddleware(stack *middleware.Stack) error {
1282  	return stack.Initialize.Add(&validateOpGetHealthCheckLastFailureReason{}, middleware.After)
1283  }
1284  
1285  func addOpGetHealthCheckStatusValidationMiddleware(stack *middleware.Stack) error {
1286  	return stack.Initialize.Add(&validateOpGetHealthCheckStatus{}, middleware.After)
1287  }
1288  
1289  func addOpGetHostedZoneValidationMiddleware(stack *middleware.Stack) error {
1290  	return stack.Initialize.Add(&validateOpGetHostedZone{}, middleware.After)
1291  }
1292  
1293  func addOpGetHostedZoneLimitValidationMiddleware(stack *middleware.Stack) error {
1294  	return stack.Initialize.Add(&validateOpGetHostedZoneLimit{}, middleware.After)
1295  }
1296  
1297  func addOpGetQueryLoggingConfigValidationMiddleware(stack *middleware.Stack) error {
1298  	return stack.Initialize.Add(&validateOpGetQueryLoggingConfig{}, middleware.After)
1299  }
1300  
1301  func addOpGetReusableDelegationSetValidationMiddleware(stack *middleware.Stack) error {
1302  	return stack.Initialize.Add(&validateOpGetReusableDelegationSet{}, middleware.After)
1303  }
1304  
1305  func addOpGetReusableDelegationSetLimitValidationMiddleware(stack *middleware.Stack) error {
1306  	return stack.Initialize.Add(&validateOpGetReusableDelegationSetLimit{}, middleware.After)
1307  }
1308  
1309  func addOpGetTrafficPolicyValidationMiddleware(stack *middleware.Stack) error {
1310  	return stack.Initialize.Add(&validateOpGetTrafficPolicy{}, middleware.After)
1311  }
1312  
1313  func addOpGetTrafficPolicyInstanceValidationMiddleware(stack *middleware.Stack) error {
1314  	return stack.Initialize.Add(&validateOpGetTrafficPolicyInstance{}, middleware.After)
1315  }
1316  
1317  func addOpListCidrBlocksValidationMiddleware(stack *middleware.Stack) error {
1318  	return stack.Initialize.Add(&validateOpListCidrBlocks{}, middleware.After)
1319  }
1320  
1321  func addOpListCidrLocationsValidationMiddleware(stack *middleware.Stack) error {
1322  	return stack.Initialize.Add(&validateOpListCidrLocations{}, middleware.After)
1323  }
1324  
1325  func addOpListHostedZonesByVPCValidationMiddleware(stack *middleware.Stack) error {
1326  	return stack.Initialize.Add(&validateOpListHostedZonesByVPC{}, middleware.After)
1327  }
1328  
1329  func addOpListResourceRecordSetsValidationMiddleware(stack *middleware.Stack) error {
1330  	return stack.Initialize.Add(&validateOpListResourceRecordSets{}, middleware.After)
1331  }
1332  
1333  func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
1334  	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
1335  }
1336  
1337  func addOpListTagsForResourcesValidationMiddleware(stack *middleware.Stack) error {
1338  	return stack.Initialize.Add(&validateOpListTagsForResources{}, middleware.After)
1339  }
1340  
1341  func addOpListTrafficPolicyInstancesByHostedZoneValidationMiddleware(stack *middleware.Stack) error {
1342  	return stack.Initialize.Add(&validateOpListTrafficPolicyInstancesByHostedZone{}, middleware.After)
1343  }
1344  
1345  func addOpListTrafficPolicyInstancesByPolicyValidationMiddleware(stack *middleware.Stack) error {
1346  	return stack.Initialize.Add(&validateOpListTrafficPolicyInstancesByPolicy{}, middleware.After)
1347  }
1348  
1349  func addOpListTrafficPolicyVersionsValidationMiddleware(stack *middleware.Stack) error {
1350  	return stack.Initialize.Add(&validateOpListTrafficPolicyVersions{}, middleware.After)
1351  }
1352  
1353  func addOpListVPCAssociationAuthorizationsValidationMiddleware(stack *middleware.Stack) error {
1354  	return stack.Initialize.Add(&validateOpListVPCAssociationAuthorizations{}, middleware.After)
1355  }
1356  
1357  func addOpTestDNSAnswerValidationMiddleware(stack *middleware.Stack) error {
1358  	return stack.Initialize.Add(&validateOpTestDNSAnswer{}, middleware.After)
1359  }
1360  
1361  func addOpUpdateHealthCheckValidationMiddleware(stack *middleware.Stack) error {
1362  	return stack.Initialize.Add(&validateOpUpdateHealthCheck{}, middleware.After)
1363  }
1364  
1365  func addOpUpdateHostedZoneCommentValidationMiddleware(stack *middleware.Stack) error {
1366  	return stack.Initialize.Add(&validateOpUpdateHostedZoneComment{}, middleware.After)
1367  }
1368  
1369  func addOpUpdateHostedZoneFeaturesValidationMiddleware(stack *middleware.Stack) error {
1370  	return stack.Initialize.Add(&validateOpUpdateHostedZoneFeatures{}, middleware.After)
1371  }
1372  
1373  func addOpUpdateTrafficPolicyCommentValidationMiddleware(stack *middleware.Stack) error {
1374  	return stack.Initialize.Add(&validateOpUpdateTrafficPolicyComment{}, middleware.After)
1375  }
1376  
1377  func addOpUpdateTrafficPolicyInstanceValidationMiddleware(stack *middleware.Stack) error {
1378  	return stack.Initialize.Add(&validateOpUpdateTrafficPolicyInstance{}, middleware.After)
1379  }
1380  
1381  func validateAlarmIdentifier(v *types.AlarmIdentifier) error {
1382  	if v == nil {
1383  		return nil
1384  	}
1385  	invalidParams := smithy.InvalidParamsError{Context: "AlarmIdentifier"}
1386  	if len(v.Region) == 0 {
1387  		invalidParams.Add(smithy.NewErrParamRequired("Region"))
1388  	}
1389  	if v.Name == nil {
1390  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1391  	}
1392  	if invalidParams.Len() > 0 {
1393  		return invalidParams
1394  	} else {
1395  		return nil
1396  	}
1397  }
1398  
1399  func validateAliasTarget(v *types.AliasTarget) error {
1400  	if v == nil {
1401  		return nil
1402  	}
1403  	invalidParams := smithy.InvalidParamsError{Context: "AliasTarget"}
1404  	if v.HostedZoneId == nil {
1405  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1406  	}
1407  	if v.DNSName == nil {
1408  		invalidParams.Add(smithy.NewErrParamRequired("DNSName"))
1409  	}
1410  	if invalidParams.Len() > 0 {
1411  		return invalidParams
1412  	} else {
1413  		return nil
1414  	}
1415  }
1416  
1417  func validateChange(v *types.Change) error {
1418  	if v == nil {
1419  		return nil
1420  	}
1421  	invalidParams := smithy.InvalidParamsError{Context: "Change"}
1422  	if len(v.Action) == 0 {
1423  		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1424  	}
1425  	if v.ResourceRecordSet == nil {
1426  		invalidParams.Add(smithy.NewErrParamRequired("ResourceRecordSet"))
1427  	} else if v.ResourceRecordSet != nil {
1428  		if err := validateResourceRecordSet(v.ResourceRecordSet); err != nil {
1429  			invalidParams.AddNested("ResourceRecordSet", err.(smithy.InvalidParamsError))
1430  		}
1431  	}
1432  	if invalidParams.Len() > 0 {
1433  		return invalidParams
1434  	} else {
1435  		return nil
1436  	}
1437  }
1438  
1439  func validateChangeBatch(v *types.ChangeBatch) error {
1440  	if v == nil {
1441  		return nil
1442  	}
1443  	invalidParams := smithy.InvalidParamsError{Context: "ChangeBatch"}
1444  	if v.Changes == nil {
1445  		invalidParams.Add(smithy.NewErrParamRequired("Changes"))
1446  	} else if v.Changes != nil {
1447  		if err := validateChanges(v.Changes); err != nil {
1448  			invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError))
1449  		}
1450  	}
1451  	if invalidParams.Len() > 0 {
1452  		return invalidParams
1453  	} else {
1454  		return nil
1455  	}
1456  }
1457  
1458  func validateChanges(v []types.Change) error {
1459  	if v == nil {
1460  		return nil
1461  	}
1462  	invalidParams := smithy.InvalidParamsError{Context: "Changes"}
1463  	for i := range v {
1464  		if err := validateChange(&v[i]); err != nil {
1465  			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1466  		}
1467  	}
1468  	if invalidParams.Len() > 0 {
1469  		return invalidParams
1470  	} else {
1471  		return nil
1472  	}
1473  }
1474  
1475  func validateCidrCollectionChange(v *types.CidrCollectionChange) error {
1476  	if v == nil {
1477  		return nil
1478  	}
1479  	invalidParams := smithy.InvalidParamsError{Context: "CidrCollectionChange"}
1480  	if v.LocationName == nil {
1481  		invalidParams.Add(smithy.NewErrParamRequired("LocationName"))
1482  	}
1483  	if len(v.Action) == 0 {
1484  		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1485  	}
1486  	if v.CidrList == nil {
1487  		invalidParams.Add(smithy.NewErrParamRequired("CidrList"))
1488  	}
1489  	if invalidParams.Len() > 0 {
1490  		return invalidParams
1491  	} else {
1492  		return nil
1493  	}
1494  }
1495  
1496  func validateCidrCollectionChanges(v []types.CidrCollectionChange) error {
1497  	if v == nil {
1498  		return nil
1499  	}
1500  	invalidParams := smithy.InvalidParamsError{Context: "CidrCollectionChanges"}
1501  	for i := range v {
1502  		if err := validateCidrCollectionChange(&v[i]); err != nil {
1503  			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1504  		}
1505  	}
1506  	if invalidParams.Len() > 0 {
1507  		return invalidParams
1508  	} else {
1509  		return nil
1510  	}
1511  }
1512  
1513  func validateCidrRoutingConfig(v *types.CidrRoutingConfig) error {
1514  	if v == nil {
1515  		return nil
1516  	}
1517  	invalidParams := smithy.InvalidParamsError{Context: "CidrRoutingConfig"}
1518  	if v.CollectionId == nil {
1519  		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
1520  	}
1521  	if v.LocationName == nil {
1522  		invalidParams.Add(smithy.NewErrParamRequired("LocationName"))
1523  	}
1524  	if invalidParams.Len() > 0 {
1525  		return invalidParams
1526  	} else {
1527  		return nil
1528  	}
1529  }
1530  
1531  func validateCoordinates(v *types.Coordinates) error {
1532  	if v == nil {
1533  		return nil
1534  	}
1535  	invalidParams := smithy.InvalidParamsError{Context: "Coordinates"}
1536  	if v.Latitude == nil {
1537  		invalidParams.Add(smithy.NewErrParamRequired("Latitude"))
1538  	}
1539  	if v.Longitude == nil {
1540  		invalidParams.Add(smithy.NewErrParamRequired("Longitude"))
1541  	}
1542  	if invalidParams.Len() > 0 {
1543  		return invalidParams
1544  	} else {
1545  		return nil
1546  	}
1547  }
1548  
1549  func validateGeoProximityLocation(v *types.GeoProximityLocation) error {
1550  	if v == nil {
1551  		return nil
1552  	}
1553  	invalidParams := smithy.InvalidParamsError{Context: "GeoProximityLocation"}
1554  	if v.Coordinates != nil {
1555  		if err := validateCoordinates(v.Coordinates); err != nil {
1556  			invalidParams.AddNested("Coordinates", err.(smithy.InvalidParamsError))
1557  		}
1558  	}
1559  	if invalidParams.Len() > 0 {
1560  		return invalidParams
1561  	} else {
1562  		return nil
1563  	}
1564  }
1565  
1566  func validateHealthCheckConfig(v *types.HealthCheckConfig) error {
1567  	if v == nil {
1568  		return nil
1569  	}
1570  	invalidParams := smithy.InvalidParamsError{Context: "HealthCheckConfig"}
1571  	if len(v.Type) == 0 {
1572  		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1573  	}
1574  	if v.AlarmIdentifier != nil {
1575  		if err := validateAlarmIdentifier(v.AlarmIdentifier); err != nil {
1576  			invalidParams.AddNested("AlarmIdentifier", err.(smithy.InvalidParamsError))
1577  		}
1578  	}
1579  	if invalidParams.Len() > 0 {
1580  		return invalidParams
1581  	} else {
1582  		return nil
1583  	}
1584  }
1585  
1586  func validateResourceRecord(v *types.ResourceRecord) error {
1587  	if v == nil {
1588  		return nil
1589  	}
1590  	invalidParams := smithy.InvalidParamsError{Context: "ResourceRecord"}
1591  	if v.Value == nil {
1592  		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1593  	}
1594  	if invalidParams.Len() > 0 {
1595  		return invalidParams
1596  	} else {
1597  		return nil
1598  	}
1599  }
1600  
1601  func validateResourceRecords(v []types.ResourceRecord) error {
1602  	if v == nil {
1603  		return nil
1604  	}
1605  	invalidParams := smithy.InvalidParamsError{Context: "ResourceRecords"}
1606  	for i := range v {
1607  		if err := validateResourceRecord(&v[i]); err != nil {
1608  			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1609  		}
1610  	}
1611  	if invalidParams.Len() > 0 {
1612  		return invalidParams
1613  	} else {
1614  		return nil
1615  	}
1616  }
1617  
1618  func validateResourceRecordSet(v *types.ResourceRecordSet) error {
1619  	if v == nil {
1620  		return nil
1621  	}
1622  	invalidParams := smithy.InvalidParamsError{Context: "ResourceRecordSet"}
1623  	if v.Name == nil {
1624  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1625  	}
1626  	if len(v.Type) == 0 {
1627  		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1628  	}
1629  	if v.ResourceRecords != nil {
1630  		if err := validateResourceRecords(v.ResourceRecords); err != nil {
1631  			invalidParams.AddNested("ResourceRecords", err.(smithy.InvalidParamsError))
1632  		}
1633  	}
1634  	if v.AliasTarget != nil {
1635  		if err := validateAliasTarget(v.AliasTarget); err != nil {
1636  			invalidParams.AddNested("AliasTarget", err.(smithy.InvalidParamsError))
1637  		}
1638  	}
1639  	if v.CidrRoutingConfig != nil {
1640  		if err := validateCidrRoutingConfig(v.CidrRoutingConfig); err != nil {
1641  			invalidParams.AddNested("CidrRoutingConfig", err.(smithy.InvalidParamsError))
1642  		}
1643  	}
1644  	if v.GeoProximityLocation != nil {
1645  		if err := validateGeoProximityLocation(v.GeoProximityLocation); err != nil {
1646  			invalidParams.AddNested("GeoProximityLocation", err.(smithy.InvalidParamsError))
1647  		}
1648  	}
1649  	if invalidParams.Len() > 0 {
1650  		return invalidParams
1651  	} else {
1652  		return nil
1653  	}
1654  }
1655  
1656  func validateOpActivateKeySigningKeyInput(v *ActivateKeySigningKeyInput) error {
1657  	if v == nil {
1658  		return nil
1659  	}
1660  	invalidParams := smithy.InvalidParamsError{Context: "ActivateKeySigningKeyInput"}
1661  	if v.HostedZoneId == nil {
1662  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1663  	}
1664  	if v.Name == nil {
1665  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1666  	}
1667  	if invalidParams.Len() > 0 {
1668  		return invalidParams
1669  	} else {
1670  		return nil
1671  	}
1672  }
1673  
1674  func validateOpAssociateVPCWithHostedZoneInput(v *AssociateVPCWithHostedZoneInput) error {
1675  	if v == nil {
1676  		return nil
1677  	}
1678  	invalidParams := smithy.InvalidParamsError{Context: "AssociateVPCWithHostedZoneInput"}
1679  	if v.HostedZoneId == nil {
1680  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1681  	}
1682  	if v.VPC == nil {
1683  		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
1684  	}
1685  	if invalidParams.Len() > 0 {
1686  		return invalidParams
1687  	} else {
1688  		return nil
1689  	}
1690  }
1691  
1692  func validateOpChangeCidrCollectionInput(v *ChangeCidrCollectionInput) error {
1693  	if v == nil {
1694  		return nil
1695  	}
1696  	invalidParams := smithy.InvalidParamsError{Context: "ChangeCidrCollectionInput"}
1697  	if v.Id == nil {
1698  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1699  	}
1700  	if v.Changes == nil {
1701  		invalidParams.Add(smithy.NewErrParamRequired("Changes"))
1702  	} else if v.Changes != nil {
1703  		if err := validateCidrCollectionChanges(v.Changes); err != nil {
1704  			invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError))
1705  		}
1706  	}
1707  	if invalidParams.Len() > 0 {
1708  		return invalidParams
1709  	} else {
1710  		return nil
1711  	}
1712  }
1713  
1714  func validateOpChangeResourceRecordSetsInput(v *ChangeResourceRecordSetsInput) error {
1715  	if v == nil {
1716  		return nil
1717  	}
1718  	invalidParams := smithy.InvalidParamsError{Context: "ChangeResourceRecordSetsInput"}
1719  	if v.HostedZoneId == nil {
1720  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1721  	}
1722  	if v.ChangeBatch == nil {
1723  		invalidParams.Add(smithy.NewErrParamRequired("ChangeBatch"))
1724  	} else if v.ChangeBatch != nil {
1725  		if err := validateChangeBatch(v.ChangeBatch); err != nil {
1726  			invalidParams.AddNested("ChangeBatch", err.(smithy.InvalidParamsError))
1727  		}
1728  	}
1729  	if invalidParams.Len() > 0 {
1730  		return invalidParams
1731  	} else {
1732  		return nil
1733  	}
1734  }
1735  
1736  func validateOpChangeTagsForResourceInput(v *ChangeTagsForResourceInput) error {
1737  	if v == nil {
1738  		return nil
1739  	}
1740  	invalidParams := smithy.InvalidParamsError{Context: "ChangeTagsForResourceInput"}
1741  	if len(v.ResourceType) == 0 {
1742  		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
1743  	}
1744  	if v.ResourceId == nil {
1745  		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1746  	}
1747  	if invalidParams.Len() > 0 {
1748  		return invalidParams
1749  	} else {
1750  		return nil
1751  	}
1752  }
1753  
1754  func validateOpCreateCidrCollectionInput(v *CreateCidrCollectionInput) error {
1755  	if v == nil {
1756  		return nil
1757  	}
1758  	invalidParams := smithy.InvalidParamsError{Context: "CreateCidrCollectionInput"}
1759  	if v.Name == nil {
1760  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1761  	}
1762  	if v.CallerReference == nil {
1763  		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
1764  	}
1765  	if invalidParams.Len() > 0 {
1766  		return invalidParams
1767  	} else {
1768  		return nil
1769  	}
1770  }
1771  
1772  func validateOpCreateHealthCheckInput(v *CreateHealthCheckInput) error {
1773  	if v == nil {
1774  		return nil
1775  	}
1776  	invalidParams := smithy.InvalidParamsError{Context: "CreateHealthCheckInput"}
1777  	if v.CallerReference == nil {
1778  		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
1779  	}
1780  	if v.HealthCheckConfig == nil {
1781  		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckConfig"))
1782  	} else if v.HealthCheckConfig != nil {
1783  		if err := validateHealthCheckConfig(v.HealthCheckConfig); err != nil {
1784  			invalidParams.AddNested("HealthCheckConfig", err.(smithy.InvalidParamsError))
1785  		}
1786  	}
1787  	if invalidParams.Len() > 0 {
1788  		return invalidParams
1789  	} else {
1790  		return nil
1791  	}
1792  }
1793  
1794  func validateOpCreateHostedZoneInput(v *CreateHostedZoneInput) error {
1795  	if v == nil {
1796  		return nil
1797  	}
1798  	invalidParams := smithy.InvalidParamsError{Context: "CreateHostedZoneInput"}
1799  	if v.Name == nil {
1800  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1801  	}
1802  	if v.CallerReference == nil {
1803  		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
1804  	}
1805  	if invalidParams.Len() > 0 {
1806  		return invalidParams
1807  	} else {
1808  		return nil
1809  	}
1810  }
1811  
1812  func validateOpCreateKeySigningKeyInput(v *CreateKeySigningKeyInput) error {
1813  	if v == nil {
1814  		return nil
1815  	}
1816  	invalidParams := smithy.InvalidParamsError{Context: "CreateKeySigningKeyInput"}
1817  	if v.CallerReference == nil {
1818  		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
1819  	}
1820  	if v.HostedZoneId == nil {
1821  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1822  	}
1823  	if v.KeyManagementServiceArn == nil {
1824  		invalidParams.Add(smithy.NewErrParamRequired("KeyManagementServiceArn"))
1825  	}
1826  	if v.Name == nil {
1827  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1828  	}
1829  	if v.Status == nil {
1830  		invalidParams.Add(smithy.NewErrParamRequired("Status"))
1831  	}
1832  	if invalidParams.Len() > 0 {
1833  		return invalidParams
1834  	} else {
1835  		return nil
1836  	}
1837  }
1838  
1839  func validateOpCreateQueryLoggingConfigInput(v *CreateQueryLoggingConfigInput) error {
1840  	if v == nil {
1841  		return nil
1842  	}
1843  	invalidParams := smithy.InvalidParamsError{Context: "CreateQueryLoggingConfigInput"}
1844  	if v.HostedZoneId == nil {
1845  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1846  	}
1847  	if v.CloudWatchLogsLogGroupArn == nil {
1848  		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogsLogGroupArn"))
1849  	}
1850  	if invalidParams.Len() > 0 {
1851  		return invalidParams
1852  	} else {
1853  		return nil
1854  	}
1855  }
1856  
1857  func validateOpCreateReusableDelegationSetInput(v *CreateReusableDelegationSetInput) error {
1858  	if v == nil {
1859  		return nil
1860  	}
1861  	invalidParams := smithy.InvalidParamsError{Context: "CreateReusableDelegationSetInput"}
1862  	if v.CallerReference == nil {
1863  		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
1864  	}
1865  	if invalidParams.Len() > 0 {
1866  		return invalidParams
1867  	} else {
1868  		return nil
1869  	}
1870  }
1871  
1872  func validateOpCreateTrafficPolicyInput(v *CreateTrafficPolicyInput) error {
1873  	if v == nil {
1874  		return nil
1875  	}
1876  	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyInput"}
1877  	if v.Name == nil {
1878  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1879  	}
1880  	if v.Document == nil {
1881  		invalidParams.Add(smithy.NewErrParamRequired("Document"))
1882  	}
1883  	if invalidParams.Len() > 0 {
1884  		return invalidParams
1885  	} else {
1886  		return nil
1887  	}
1888  }
1889  
1890  func validateOpCreateTrafficPolicyInstanceInput(v *CreateTrafficPolicyInstanceInput) error {
1891  	if v == nil {
1892  		return nil
1893  	}
1894  	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyInstanceInput"}
1895  	if v.HostedZoneId == nil {
1896  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1897  	}
1898  	if v.Name == nil {
1899  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1900  	}
1901  	if v.TTL == nil {
1902  		invalidParams.Add(smithy.NewErrParamRequired("TTL"))
1903  	}
1904  	if v.TrafficPolicyId == nil {
1905  		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
1906  	}
1907  	if v.TrafficPolicyVersion == nil {
1908  		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
1909  	}
1910  	if invalidParams.Len() > 0 {
1911  		return invalidParams
1912  	} else {
1913  		return nil
1914  	}
1915  }
1916  
1917  func validateOpCreateTrafficPolicyVersionInput(v *CreateTrafficPolicyVersionInput) error {
1918  	if v == nil {
1919  		return nil
1920  	}
1921  	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyVersionInput"}
1922  	if v.Id == nil {
1923  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1924  	}
1925  	if v.Document == nil {
1926  		invalidParams.Add(smithy.NewErrParamRequired("Document"))
1927  	}
1928  	if invalidParams.Len() > 0 {
1929  		return invalidParams
1930  	} else {
1931  		return nil
1932  	}
1933  }
1934  
1935  func validateOpCreateVPCAssociationAuthorizationInput(v *CreateVPCAssociationAuthorizationInput) error {
1936  	if v == nil {
1937  		return nil
1938  	}
1939  	invalidParams := smithy.InvalidParamsError{Context: "CreateVPCAssociationAuthorizationInput"}
1940  	if v.HostedZoneId == nil {
1941  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1942  	}
1943  	if v.VPC == nil {
1944  		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
1945  	}
1946  	if invalidParams.Len() > 0 {
1947  		return invalidParams
1948  	} else {
1949  		return nil
1950  	}
1951  }
1952  
1953  func validateOpDeactivateKeySigningKeyInput(v *DeactivateKeySigningKeyInput) error {
1954  	if v == nil {
1955  		return nil
1956  	}
1957  	invalidParams := smithy.InvalidParamsError{Context: "DeactivateKeySigningKeyInput"}
1958  	if v.HostedZoneId == nil {
1959  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
1960  	}
1961  	if v.Name == nil {
1962  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1963  	}
1964  	if invalidParams.Len() > 0 {
1965  		return invalidParams
1966  	} else {
1967  		return nil
1968  	}
1969  }
1970  
1971  func validateOpDeleteCidrCollectionInput(v *DeleteCidrCollectionInput) error {
1972  	if v == nil {
1973  		return nil
1974  	}
1975  	invalidParams := smithy.InvalidParamsError{Context: "DeleteCidrCollectionInput"}
1976  	if v.Id == nil {
1977  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1978  	}
1979  	if invalidParams.Len() > 0 {
1980  		return invalidParams
1981  	} else {
1982  		return nil
1983  	}
1984  }
1985  
1986  func validateOpDeleteHealthCheckInput(v *DeleteHealthCheckInput) error {
1987  	if v == nil {
1988  		return nil
1989  	}
1990  	invalidParams := smithy.InvalidParamsError{Context: "DeleteHealthCheckInput"}
1991  	if v.HealthCheckId == nil {
1992  		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
1993  	}
1994  	if invalidParams.Len() > 0 {
1995  		return invalidParams
1996  	} else {
1997  		return nil
1998  	}
1999  }
2000  
2001  func validateOpDeleteHostedZoneInput(v *DeleteHostedZoneInput) error {
2002  	if v == nil {
2003  		return nil
2004  	}
2005  	invalidParams := smithy.InvalidParamsError{Context: "DeleteHostedZoneInput"}
2006  	if v.Id == nil {
2007  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2008  	}
2009  	if invalidParams.Len() > 0 {
2010  		return invalidParams
2011  	} else {
2012  		return nil
2013  	}
2014  }
2015  
2016  func validateOpDeleteKeySigningKeyInput(v *DeleteKeySigningKeyInput) error {
2017  	if v == nil {
2018  		return nil
2019  	}
2020  	invalidParams := smithy.InvalidParamsError{Context: "DeleteKeySigningKeyInput"}
2021  	if v.HostedZoneId == nil {
2022  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2023  	}
2024  	if v.Name == nil {
2025  		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2026  	}
2027  	if invalidParams.Len() > 0 {
2028  		return invalidParams
2029  	} else {
2030  		return nil
2031  	}
2032  }
2033  
2034  func validateOpDeleteQueryLoggingConfigInput(v *DeleteQueryLoggingConfigInput) error {
2035  	if v == nil {
2036  		return nil
2037  	}
2038  	invalidParams := smithy.InvalidParamsError{Context: "DeleteQueryLoggingConfigInput"}
2039  	if v.Id == nil {
2040  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2041  	}
2042  	if invalidParams.Len() > 0 {
2043  		return invalidParams
2044  	} else {
2045  		return nil
2046  	}
2047  }
2048  
2049  func validateOpDeleteReusableDelegationSetInput(v *DeleteReusableDelegationSetInput) error {
2050  	if v == nil {
2051  		return nil
2052  	}
2053  	invalidParams := smithy.InvalidParamsError{Context: "DeleteReusableDelegationSetInput"}
2054  	if v.Id == nil {
2055  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2056  	}
2057  	if invalidParams.Len() > 0 {
2058  		return invalidParams
2059  	} else {
2060  		return nil
2061  	}
2062  }
2063  
2064  func validateOpDeleteTrafficPolicyInput(v *DeleteTrafficPolicyInput) error {
2065  	if v == nil {
2066  		return nil
2067  	}
2068  	invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficPolicyInput"}
2069  	if v.Id == nil {
2070  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2071  	}
2072  	if v.Version == nil {
2073  		invalidParams.Add(smithy.NewErrParamRequired("Version"))
2074  	}
2075  	if invalidParams.Len() > 0 {
2076  		return invalidParams
2077  	} else {
2078  		return nil
2079  	}
2080  }
2081  
2082  func validateOpDeleteTrafficPolicyInstanceInput(v *DeleteTrafficPolicyInstanceInput) error {
2083  	if v == nil {
2084  		return nil
2085  	}
2086  	invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficPolicyInstanceInput"}
2087  	if v.Id == nil {
2088  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2089  	}
2090  	if invalidParams.Len() > 0 {
2091  		return invalidParams
2092  	} else {
2093  		return nil
2094  	}
2095  }
2096  
2097  func validateOpDeleteVPCAssociationAuthorizationInput(v *DeleteVPCAssociationAuthorizationInput) error {
2098  	if v == nil {
2099  		return nil
2100  	}
2101  	invalidParams := smithy.InvalidParamsError{Context: "DeleteVPCAssociationAuthorizationInput"}
2102  	if v.HostedZoneId == nil {
2103  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2104  	}
2105  	if v.VPC == nil {
2106  		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
2107  	}
2108  	if invalidParams.Len() > 0 {
2109  		return invalidParams
2110  	} else {
2111  		return nil
2112  	}
2113  }
2114  
2115  func validateOpDisableHostedZoneDNSSECInput(v *DisableHostedZoneDNSSECInput) error {
2116  	if v == nil {
2117  		return nil
2118  	}
2119  	invalidParams := smithy.InvalidParamsError{Context: "DisableHostedZoneDNSSECInput"}
2120  	if v.HostedZoneId == nil {
2121  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2122  	}
2123  	if invalidParams.Len() > 0 {
2124  		return invalidParams
2125  	} else {
2126  		return nil
2127  	}
2128  }
2129  
2130  func validateOpDisassociateVPCFromHostedZoneInput(v *DisassociateVPCFromHostedZoneInput) error {
2131  	if v == nil {
2132  		return nil
2133  	}
2134  	invalidParams := smithy.InvalidParamsError{Context: "DisassociateVPCFromHostedZoneInput"}
2135  	if v.HostedZoneId == nil {
2136  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2137  	}
2138  	if v.VPC == nil {
2139  		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
2140  	}
2141  	if invalidParams.Len() > 0 {
2142  		return invalidParams
2143  	} else {
2144  		return nil
2145  	}
2146  }
2147  
2148  func validateOpEnableHostedZoneDNSSECInput(v *EnableHostedZoneDNSSECInput) error {
2149  	if v == nil {
2150  		return nil
2151  	}
2152  	invalidParams := smithy.InvalidParamsError{Context: "EnableHostedZoneDNSSECInput"}
2153  	if v.HostedZoneId == nil {
2154  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2155  	}
2156  	if invalidParams.Len() > 0 {
2157  		return invalidParams
2158  	} else {
2159  		return nil
2160  	}
2161  }
2162  
2163  func validateOpGetAccountLimitInput(v *GetAccountLimitInput) error {
2164  	if v == nil {
2165  		return nil
2166  	}
2167  	invalidParams := smithy.InvalidParamsError{Context: "GetAccountLimitInput"}
2168  	if len(v.Type) == 0 {
2169  		invalidParams.Add(smithy.NewErrParamRequired("Type"))
2170  	}
2171  	if invalidParams.Len() > 0 {
2172  		return invalidParams
2173  	} else {
2174  		return nil
2175  	}
2176  }
2177  
2178  func validateOpGetChangeInput(v *GetChangeInput) error {
2179  	if v == nil {
2180  		return nil
2181  	}
2182  	invalidParams := smithy.InvalidParamsError{Context: "GetChangeInput"}
2183  	if v.Id == nil {
2184  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2185  	}
2186  	if invalidParams.Len() > 0 {
2187  		return invalidParams
2188  	} else {
2189  		return nil
2190  	}
2191  }
2192  
2193  func validateOpGetDNSSECInput(v *GetDNSSECInput) error {
2194  	if v == nil {
2195  		return nil
2196  	}
2197  	invalidParams := smithy.InvalidParamsError{Context: "GetDNSSECInput"}
2198  	if v.HostedZoneId == nil {
2199  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2200  	}
2201  	if invalidParams.Len() > 0 {
2202  		return invalidParams
2203  	} else {
2204  		return nil
2205  	}
2206  }
2207  
2208  func validateOpGetHealthCheckInput(v *GetHealthCheckInput) error {
2209  	if v == nil {
2210  		return nil
2211  	}
2212  	invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckInput"}
2213  	if v.HealthCheckId == nil {
2214  		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
2215  	}
2216  	if invalidParams.Len() > 0 {
2217  		return invalidParams
2218  	} else {
2219  		return nil
2220  	}
2221  }
2222  
2223  func validateOpGetHealthCheckLastFailureReasonInput(v *GetHealthCheckLastFailureReasonInput) error {
2224  	if v == nil {
2225  		return nil
2226  	}
2227  	invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckLastFailureReasonInput"}
2228  	if v.HealthCheckId == nil {
2229  		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
2230  	}
2231  	if invalidParams.Len() > 0 {
2232  		return invalidParams
2233  	} else {
2234  		return nil
2235  	}
2236  }
2237  
2238  func validateOpGetHealthCheckStatusInput(v *GetHealthCheckStatusInput) error {
2239  	if v == nil {
2240  		return nil
2241  	}
2242  	invalidParams := smithy.InvalidParamsError{Context: "GetHealthCheckStatusInput"}
2243  	if v.HealthCheckId == nil {
2244  		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
2245  	}
2246  	if invalidParams.Len() > 0 {
2247  		return invalidParams
2248  	} else {
2249  		return nil
2250  	}
2251  }
2252  
2253  func validateOpGetHostedZoneInput(v *GetHostedZoneInput) error {
2254  	if v == nil {
2255  		return nil
2256  	}
2257  	invalidParams := smithy.InvalidParamsError{Context: "GetHostedZoneInput"}
2258  	if v.Id == nil {
2259  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2260  	}
2261  	if invalidParams.Len() > 0 {
2262  		return invalidParams
2263  	} else {
2264  		return nil
2265  	}
2266  }
2267  
2268  func validateOpGetHostedZoneLimitInput(v *GetHostedZoneLimitInput) error {
2269  	if v == nil {
2270  		return nil
2271  	}
2272  	invalidParams := smithy.InvalidParamsError{Context: "GetHostedZoneLimitInput"}
2273  	if len(v.Type) == 0 {
2274  		invalidParams.Add(smithy.NewErrParamRequired("Type"))
2275  	}
2276  	if v.HostedZoneId == nil {
2277  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2278  	}
2279  	if invalidParams.Len() > 0 {
2280  		return invalidParams
2281  	} else {
2282  		return nil
2283  	}
2284  }
2285  
2286  func validateOpGetQueryLoggingConfigInput(v *GetQueryLoggingConfigInput) error {
2287  	if v == nil {
2288  		return nil
2289  	}
2290  	invalidParams := smithy.InvalidParamsError{Context: "GetQueryLoggingConfigInput"}
2291  	if v.Id == nil {
2292  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2293  	}
2294  	if invalidParams.Len() > 0 {
2295  		return invalidParams
2296  	} else {
2297  		return nil
2298  	}
2299  }
2300  
2301  func validateOpGetReusableDelegationSetInput(v *GetReusableDelegationSetInput) error {
2302  	if v == nil {
2303  		return nil
2304  	}
2305  	invalidParams := smithy.InvalidParamsError{Context: "GetReusableDelegationSetInput"}
2306  	if v.Id == nil {
2307  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2308  	}
2309  	if invalidParams.Len() > 0 {
2310  		return invalidParams
2311  	} else {
2312  		return nil
2313  	}
2314  }
2315  
2316  func validateOpGetReusableDelegationSetLimitInput(v *GetReusableDelegationSetLimitInput) error {
2317  	if v == nil {
2318  		return nil
2319  	}
2320  	invalidParams := smithy.InvalidParamsError{Context: "GetReusableDelegationSetLimitInput"}
2321  	if len(v.Type) == 0 {
2322  		invalidParams.Add(smithy.NewErrParamRequired("Type"))
2323  	}
2324  	if v.DelegationSetId == nil {
2325  		invalidParams.Add(smithy.NewErrParamRequired("DelegationSetId"))
2326  	}
2327  	if invalidParams.Len() > 0 {
2328  		return invalidParams
2329  	} else {
2330  		return nil
2331  	}
2332  }
2333  
2334  func validateOpGetTrafficPolicyInput(v *GetTrafficPolicyInput) error {
2335  	if v == nil {
2336  		return nil
2337  	}
2338  	invalidParams := smithy.InvalidParamsError{Context: "GetTrafficPolicyInput"}
2339  	if v.Id == nil {
2340  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2341  	}
2342  	if v.Version == nil {
2343  		invalidParams.Add(smithy.NewErrParamRequired("Version"))
2344  	}
2345  	if invalidParams.Len() > 0 {
2346  		return invalidParams
2347  	} else {
2348  		return nil
2349  	}
2350  }
2351  
2352  func validateOpGetTrafficPolicyInstanceInput(v *GetTrafficPolicyInstanceInput) error {
2353  	if v == nil {
2354  		return nil
2355  	}
2356  	invalidParams := smithy.InvalidParamsError{Context: "GetTrafficPolicyInstanceInput"}
2357  	if v.Id == nil {
2358  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2359  	}
2360  	if invalidParams.Len() > 0 {
2361  		return invalidParams
2362  	} else {
2363  		return nil
2364  	}
2365  }
2366  
2367  func validateOpListCidrBlocksInput(v *ListCidrBlocksInput) error {
2368  	if v == nil {
2369  		return nil
2370  	}
2371  	invalidParams := smithy.InvalidParamsError{Context: "ListCidrBlocksInput"}
2372  	if v.CollectionId == nil {
2373  		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
2374  	}
2375  	if invalidParams.Len() > 0 {
2376  		return invalidParams
2377  	} else {
2378  		return nil
2379  	}
2380  }
2381  
2382  func validateOpListCidrLocationsInput(v *ListCidrLocationsInput) error {
2383  	if v == nil {
2384  		return nil
2385  	}
2386  	invalidParams := smithy.InvalidParamsError{Context: "ListCidrLocationsInput"}
2387  	if v.CollectionId == nil {
2388  		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
2389  	}
2390  	if invalidParams.Len() > 0 {
2391  		return invalidParams
2392  	} else {
2393  		return nil
2394  	}
2395  }
2396  
2397  func validateOpListHostedZonesByVPCInput(v *ListHostedZonesByVPCInput) error {
2398  	if v == nil {
2399  		return nil
2400  	}
2401  	invalidParams := smithy.InvalidParamsError{Context: "ListHostedZonesByVPCInput"}
2402  	if v.VPCId == nil {
2403  		invalidParams.Add(smithy.NewErrParamRequired("VPCId"))
2404  	}
2405  	if len(v.VPCRegion) == 0 {
2406  		invalidParams.Add(smithy.NewErrParamRequired("VPCRegion"))
2407  	}
2408  	if invalidParams.Len() > 0 {
2409  		return invalidParams
2410  	} else {
2411  		return nil
2412  	}
2413  }
2414  
2415  func validateOpListResourceRecordSetsInput(v *ListResourceRecordSetsInput) error {
2416  	if v == nil {
2417  		return nil
2418  	}
2419  	invalidParams := smithy.InvalidParamsError{Context: "ListResourceRecordSetsInput"}
2420  	if v.HostedZoneId == nil {
2421  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2422  	}
2423  	if invalidParams.Len() > 0 {
2424  		return invalidParams
2425  	} else {
2426  		return nil
2427  	}
2428  }
2429  
2430  func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
2431  	if v == nil {
2432  		return nil
2433  	}
2434  	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
2435  	if len(v.ResourceType) == 0 {
2436  		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2437  	}
2438  	if v.ResourceId == nil {
2439  		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
2440  	}
2441  	if invalidParams.Len() > 0 {
2442  		return invalidParams
2443  	} else {
2444  		return nil
2445  	}
2446  }
2447  
2448  func validateOpListTagsForResourcesInput(v *ListTagsForResourcesInput) error {
2449  	if v == nil {
2450  		return nil
2451  	}
2452  	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourcesInput"}
2453  	if len(v.ResourceType) == 0 {
2454  		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2455  	}
2456  	if v.ResourceIds == nil {
2457  		invalidParams.Add(smithy.NewErrParamRequired("ResourceIds"))
2458  	}
2459  	if invalidParams.Len() > 0 {
2460  		return invalidParams
2461  	} else {
2462  		return nil
2463  	}
2464  }
2465  
2466  func validateOpListTrafficPolicyInstancesByHostedZoneInput(v *ListTrafficPolicyInstancesByHostedZoneInput) error {
2467  	if v == nil {
2468  		return nil
2469  	}
2470  	invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyInstancesByHostedZoneInput"}
2471  	if v.HostedZoneId == nil {
2472  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2473  	}
2474  	if invalidParams.Len() > 0 {
2475  		return invalidParams
2476  	} else {
2477  		return nil
2478  	}
2479  }
2480  
2481  func validateOpListTrafficPolicyInstancesByPolicyInput(v *ListTrafficPolicyInstancesByPolicyInput) error {
2482  	if v == nil {
2483  		return nil
2484  	}
2485  	invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyInstancesByPolicyInput"}
2486  	if v.TrafficPolicyId == nil {
2487  		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
2488  	}
2489  	if v.TrafficPolicyVersion == nil {
2490  		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
2491  	}
2492  	if invalidParams.Len() > 0 {
2493  		return invalidParams
2494  	} else {
2495  		return nil
2496  	}
2497  }
2498  
2499  func validateOpListTrafficPolicyVersionsInput(v *ListTrafficPolicyVersionsInput) error {
2500  	if v == nil {
2501  		return nil
2502  	}
2503  	invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyVersionsInput"}
2504  	if v.Id == nil {
2505  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2506  	}
2507  	if invalidParams.Len() > 0 {
2508  		return invalidParams
2509  	} else {
2510  		return nil
2511  	}
2512  }
2513  
2514  func validateOpListVPCAssociationAuthorizationsInput(v *ListVPCAssociationAuthorizationsInput) error {
2515  	if v == nil {
2516  		return nil
2517  	}
2518  	invalidParams := smithy.InvalidParamsError{Context: "ListVPCAssociationAuthorizationsInput"}
2519  	if v.HostedZoneId == nil {
2520  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2521  	}
2522  	if invalidParams.Len() > 0 {
2523  		return invalidParams
2524  	} else {
2525  		return nil
2526  	}
2527  }
2528  
2529  func validateOpTestDNSAnswerInput(v *TestDNSAnswerInput) error {
2530  	if v == nil {
2531  		return nil
2532  	}
2533  	invalidParams := smithy.InvalidParamsError{Context: "TestDNSAnswerInput"}
2534  	if v.HostedZoneId == nil {
2535  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2536  	}
2537  	if v.RecordName == nil {
2538  		invalidParams.Add(smithy.NewErrParamRequired("RecordName"))
2539  	}
2540  	if len(v.RecordType) == 0 {
2541  		invalidParams.Add(smithy.NewErrParamRequired("RecordType"))
2542  	}
2543  	if invalidParams.Len() > 0 {
2544  		return invalidParams
2545  	} else {
2546  		return nil
2547  	}
2548  }
2549  
2550  func validateOpUpdateHealthCheckInput(v *UpdateHealthCheckInput) error {
2551  	if v == nil {
2552  		return nil
2553  	}
2554  	invalidParams := smithy.InvalidParamsError{Context: "UpdateHealthCheckInput"}
2555  	if v.HealthCheckId == nil {
2556  		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
2557  	}
2558  	if v.AlarmIdentifier != nil {
2559  		if err := validateAlarmIdentifier(v.AlarmIdentifier); err != nil {
2560  			invalidParams.AddNested("AlarmIdentifier", err.(smithy.InvalidParamsError))
2561  		}
2562  	}
2563  	if invalidParams.Len() > 0 {
2564  		return invalidParams
2565  	} else {
2566  		return nil
2567  	}
2568  }
2569  
2570  func validateOpUpdateHostedZoneCommentInput(v *UpdateHostedZoneCommentInput) error {
2571  	if v == nil {
2572  		return nil
2573  	}
2574  	invalidParams := smithy.InvalidParamsError{Context: "UpdateHostedZoneCommentInput"}
2575  	if v.Id == nil {
2576  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2577  	}
2578  	if invalidParams.Len() > 0 {
2579  		return invalidParams
2580  	} else {
2581  		return nil
2582  	}
2583  }
2584  
2585  func validateOpUpdateHostedZoneFeaturesInput(v *UpdateHostedZoneFeaturesInput) error {
2586  	if v == nil {
2587  		return nil
2588  	}
2589  	invalidParams := smithy.InvalidParamsError{Context: "UpdateHostedZoneFeaturesInput"}
2590  	if v.HostedZoneId == nil {
2591  		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
2592  	}
2593  	if invalidParams.Len() > 0 {
2594  		return invalidParams
2595  	} else {
2596  		return nil
2597  	}
2598  }
2599  
2600  func validateOpUpdateTrafficPolicyCommentInput(v *UpdateTrafficPolicyCommentInput) error {
2601  	if v == nil {
2602  		return nil
2603  	}
2604  	invalidParams := smithy.InvalidParamsError{Context: "UpdateTrafficPolicyCommentInput"}
2605  	if v.Id == nil {
2606  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2607  	}
2608  	if v.Version == nil {
2609  		invalidParams.Add(smithy.NewErrParamRequired("Version"))
2610  	}
2611  	if v.Comment == nil {
2612  		invalidParams.Add(smithy.NewErrParamRequired("Comment"))
2613  	}
2614  	if invalidParams.Len() > 0 {
2615  		return invalidParams
2616  	} else {
2617  		return nil
2618  	}
2619  }
2620  
2621  func validateOpUpdateTrafficPolicyInstanceInput(v *UpdateTrafficPolicyInstanceInput) error {
2622  	if v == nil {
2623  		return nil
2624  	}
2625  	invalidParams := smithy.InvalidParamsError{Context: "UpdateTrafficPolicyInstanceInput"}
2626  	if v.Id == nil {
2627  		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2628  	}
2629  	if v.TTL == nil {
2630  		invalidParams.Add(smithy.NewErrParamRequired("TTL"))
2631  	}
2632  	if v.TrafficPolicyId == nil {
2633  		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
2634  	}
2635  	if v.TrafficPolicyVersion == nil {
2636  		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
2637  	}
2638  	if invalidParams.Len() > 0 {
2639  		return invalidParams
2640  	} else {
2641  		return nil
2642  	}
2643  }
2644