validators.go raw

   1  // Code generated by smithy-go-codegen DO NOT EDIT.
   2  
   3  package lightsail
   4  
   5  import (
   6  	"context"
   7  	"fmt"
   8  	"github.com/aws/aws-sdk-go-v2/service/lightsail/types"
   9  	smithy "github.com/aws/smithy-go"
  10  	"github.com/aws/smithy-go/middleware"
  11  )
  12  
  13  type validateOpAllocateStaticIp struct {
  14  }
  15  
  16  func (*validateOpAllocateStaticIp) ID() string {
  17  	return "OperationInputValidation"
  18  }
  19  
  20  func (m *validateOpAllocateStaticIp) 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.(*AllocateStaticIpInput)
  24  	if !ok {
  25  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
  26  	}
  27  	if err := validateOpAllocateStaticIpInput(input); err != nil {
  28  		return out, metadata, err
  29  	}
  30  	return next.HandleInitialize(ctx, in)
  31  }
  32  
  33  type validateOpAttachCertificateToDistribution struct {
  34  }
  35  
  36  func (*validateOpAttachCertificateToDistribution) ID() string {
  37  	return "OperationInputValidation"
  38  }
  39  
  40  func (m *validateOpAttachCertificateToDistribution) 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.(*AttachCertificateToDistributionInput)
  44  	if !ok {
  45  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
  46  	}
  47  	if err := validateOpAttachCertificateToDistributionInput(input); err != nil {
  48  		return out, metadata, err
  49  	}
  50  	return next.HandleInitialize(ctx, in)
  51  }
  52  
  53  type validateOpAttachDisk struct {
  54  }
  55  
  56  func (*validateOpAttachDisk) ID() string {
  57  	return "OperationInputValidation"
  58  }
  59  
  60  func (m *validateOpAttachDisk) 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.(*AttachDiskInput)
  64  	if !ok {
  65  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
  66  	}
  67  	if err := validateOpAttachDiskInput(input); err != nil {
  68  		return out, metadata, err
  69  	}
  70  	return next.HandleInitialize(ctx, in)
  71  }
  72  
  73  type validateOpAttachInstancesToLoadBalancer struct {
  74  }
  75  
  76  func (*validateOpAttachInstancesToLoadBalancer) ID() string {
  77  	return "OperationInputValidation"
  78  }
  79  
  80  func (m *validateOpAttachInstancesToLoadBalancer) 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.(*AttachInstancesToLoadBalancerInput)
  84  	if !ok {
  85  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
  86  	}
  87  	if err := validateOpAttachInstancesToLoadBalancerInput(input); err != nil {
  88  		return out, metadata, err
  89  	}
  90  	return next.HandleInitialize(ctx, in)
  91  }
  92  
  93  type validateOpAttachLoadBalancerTlsCertificate struct {
  94  }
  95  
  96  func (*validateOpAttachLoadBalancerTlsCertificate) ID() string {
  97  	return "OperationInputValidation"
  98  }
  99  
 100  func (m *validateOpAttachLoadBalancerTlsCertificate) 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.(*AttachLoadBalancerTlsCertificateInput)
 104  	if !ok {
 105  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 106  	}
 107  	if err := validateOpAttachLoadBalancerTlsCertificateInput(input); err != nil {
 108  		return out, metadata, err
 109  	}
 110  	return next.HandleInitialize(ctx, in)
 111  }
 112  
 113  type validateOpAttachStaticIp struct {
 114  }
 115  
 116  func (*validateOpAttachStaticIp) ID() string {
 117  	return "OperationInputValidation"
 118  }
 119  
 120  func (m *validateOpAttachStaticIp) 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.(*AttachStaticIpInput)
 124  	if !ok {
 125  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 126  	}
 127  	if err := validateOpAttachStaticIpInput(input); err != nil {
 128  		return out, metadata, err
 129  	}
 130  	return next.HandleInitialize(ctx, in)
 131  }
 132  
 133  type validateOpCloseInstancePublicPorts struct {
 134  }
 135  
 136  func (*validateOpCloseInstancePublicPorts) ID() string {
 137  	return "OperationInputValidation"
 138  }
 139  
 140  func (m *validateOpCloseInstancePublicPorts) 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.(*CloseInstancePublicPortsInput)
 144  	if !ok {
 145  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 146  	}
 147  	if err := validateOpCloseInstancePublicPortsInput(input); err != nil {
 148  		return out, metadata, err
 149  	}
 150  	return next.HandleInitialize(ctx, in)
 151  }
 152  
 153  type validateOpCopySnapshot struct {
 154  }
 155  
 156  func (*validateOpCopySnapshot) ID() string {
 157  	return "OperationInputValidation"
 158  }
 159  
 160  func (m *validateOpCopySnapshot) 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.(*CopySnapshotInput)
 164  	if !ok {
 165  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 166  	}
 167  	if err := validateOpCopySnapshotInput(input); err != nil {
 168  		return out, metadata, err
 169  	}
 170  	return next.HandleInitialize(ctx, in)
 171  }
 172  
 173  type validateOpCreateBucketAccessKey struct {
 174  }
 175  
 176  func (*validateOpCreateBucketAccessKey) ID() string {
 177  	return "OperationInputValidation"
 178  }
 179  
 180  func (m *validateOpCreateBucketAccessKey) 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.(*CreateBucketAccessKeyInput)
 184  	if !ok {
 185  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 186  	}
 187  	if err := validateOpCreateBucketAccessKeyInput(input); err != nil {
 188  		return out, metadata, err
 189  	}
 190  	return next.HandleInitialize(ctx, in)
 191  }
 192  
 193  type validateOpCreateBucket struct {
 194  }
 195  
 196  func (*validateOpCreateBucket) ID() string {
 197  	return "OperationInputValidation"
 198  }
 199  
 200  func (m *validateOpCreateBucket) 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.(*CreateBucketInput)
 204  	if !ok {
 205  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 206  	}
 207  	if err := validateOpCreateBucketInput(input); err != nil {
 208  		return out, metadata, err
 209  	}
 210  	return next.HandleInitialize(ctx, in)
 211  }
 212  
 213  type validateOpCreateCertificate struct {
 214  }
 215  
 216  func (*validateOpCreateCertificate) ID() string {
 217  	return "OperationInputValidation"
 218  }
 219  
 220  func (m *validateOpCreateCertificate) 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.(*CreateCertificateInput)
 224  	if !ok {
 225  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 226  	}
 227  	if err := validateOpCreateCertificateInput(input); err != nil {
 228  		return out, metadata, err
 229  	}
 230  	return next.HandleInitialize(ctx, in)
 231  }
 232  
 233  type validateOpCreateCloudFormationStack struct {
 234  }
 235  
 236  func (*validateOpCreateCloudFormationStack) ID() string {
 237  	return "OperationInputValidation"
 238  }
 239  
 240  func (m *validateOpCreateCloudFormationStack) 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.(*CreateCloudFormationStackInput)
 244  	if !ok {
 245  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 246  	}
 247  	if err := validateOpCreateCloudFormationStackInput(input); err != nil {
 248  		return out, metadata, err
 249  	}
 250  	return next.HandleInitialize(ctx, in)
 251  }
 252  
 253  type validateOpCreateContactMethod struct {
 254  }
 255  
 256  func (*validateOpCreateContactMethod) ID() string {
 257  	return "OperationInputValidation"
 258  }
 259  
 260  func (m *validateOpCreateContactMethod) 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.(*CreateContactMethodInput)
 264  	if !ok {
 265  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 266  	}
 267  	if err := validateOpCreateContactMethodInput(input); err != nil {
 268  		return out, metadata, err
 269  	}
 270  	return next.HandleInitialize(ctx, in)
 271  }
 272  
 273  type validateOpCreateContainerServiceDeployment struct {
 274  }
 275  
 276  func (*validateOpCreateContainerServiceDeployment) ID() string {
 277  	return "OperationInputValidation"
 278  }
 279  
 280  func (m *validateOpCreateContainerServiceDeployment) 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.(*CreateContainerServiceDeploymentInput)
 284  	if !ok {
 285  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 286  	}
 287  	if err := validateOpCreateContainerServiceDeploymentInput(input); err != nil {
 288  		return out, metadata, err
 289  	}
 290  	return next.HandleInitialize(ctx, in)
 291  }
 292  
 293  type validateOpCreateContainerService struct {
 294  }
 295  
 296  func (*validateOpCreateContainerService) ID() string {
 297  	return "OperationInputValidation"
 298  }
 299  
 300  func (m *validateOpCreateContainerService) 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.(*CreateContainerServiceInput)
 304  	if !ok {
 305  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 306  	}
 307  	if err := validateOpCreateContainerServiceInput(input); err != nil {
 308  		return out, metadata, err
 309  	}
 310  	return next.HandleInitialize(ctx, in)
 311  }
 312  
 313  type validateOpCreateDiskFromSnapshot struct {
 314  }
 315  
 316  func (*validateOpCreateDiskFromSnapshot) ID() string {
 317  	return "OperationInputValidation"
 318  }
 319  
 320  func (m *validateOpCreateDiskFromSnapshot) 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.(*CreateDiskFromSnapshotInput)
 324  	if !ok {
 325  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 326  	}
 327  	if err := validateOpCreateDiskFromSnapshotInput(input); err != nil {
 328  		return out, metadata, err
 329  	}
 330  	return next.HandleInitialize(ctx, in)
 331  }
 332  
 333  type validateOpCreateDisk struct {
 334  }
 335  
 336  func (*validateOpCreateDisk) ID() string {
 337  	return "OperationInputValidation"
 338  }
 339  
 340  func (m *validateOpCreateDisk) 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.(*CreateDiskInput)
 344  	if !ok {
 345  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 346  	}
 347  	if err := validateOpCreateDiskInput(input); err != nil {
 348  		return out, metadata, err
 349  	}
 350  	return next.HandleInitialize(ctx, in)
 351  }
 352  
 353  type validateOpCreateDiskSnapshot struct {
 354  }
 355  
 356  func (*validateOpCreateDiskSnapshot) ID() string {
 357  	return "OperationInputValidation"
 358  }
 359  
 360  func (m *validateOpCreateDiskSnapshot) 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.(*CreateDiskSnapshotInput)
 364  	if !ok {
 365  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 366  	}
 367  	if err := validateOpCreateDiskSnapshotInput(input); err != nil {
 368  		return out, metadata, err
 369  	}
 370  	return next.HandleInitialize(ctx, in)
 371  }
 372  
 373  type validateOpCreateDistribution struct {
 374  }
 375  
 376  func (*validateOpCreateDistribution) ID() string {
 377  	return "OperationInputValidation"
 378  }
 379  
 380  func (m *validateOpCreateDistribution) 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.(*CreateDistributionInput)
 384  	if !ok {
 385  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 386  	}
 387  	if err := validateOpCreateDistributionInput(input); err != nil {
 388  		return out, metadata, err
 389  	}
 390  	return next.HandleInitialize(ctx, in)
 391  }
 392  
 393  type validateOpCreateDomainEntry struct {
 394  }
 395  
 396  func (*validateOpCreateDomainEntry) ID() string {
 397  	return "OperationInputValidation"
 398  }
 399  
 400  func (m *validateOpCreateDomainEntry) 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.(*CreateDomainEntryInput)
 404  	if !ok {
 405  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 406  	}
 407  	if err := validateOpCreateDomainEntryInput(input); err != nil {
 408  		return out, metadata, err
 409  	}
 410  	return next.HandleInitialize(ctx, in)
 411  }
 412  
 413  type validateOpCreateDomain struct {
 414  }
 415  
 416  func (*validateOpCreateDomain) ID() string {
 417  	return "OperationInputValidation"
 418  }
 419  
 420  func (m *validateOpCreateDomain) 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.(*CreateDomainInput)
 424  	if !ok {
 425  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 426  	}
 427  	if err := validateOpCreateDomainInput(input); err != nil {
 428  		return out, metadata, err
 429  	}
 430  	return next.HandleInitialize(ctx, in)
 431  }
 432  
 433  type validateOpCreateGUISessionAccessDetails struct {
 434  }
 435  
 436  func (*validateOpCreateGUISessionAccessDetails) ID() string {
 437  	return "OperationInputValidation"
 438  }
 439  
 440  func (m *validateOpCreateGUISessionAccessDetails) 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.(*CreateGUISessionAccessDetailsInput)
 444  	if !ok {
 445  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 446  	}
 447  	if err := validateOpCreateGUISessionAccessDetailsInput(input); err != nil {
 448  		return out, metadata, err
 449  	}
 450  	return next.HandleInitialize(ctx, in)
 451  }
 452  
 453  type validateOpCreateInstancesFromSnapshot struct {
 454  }
 455  
 456  func (*validateOpCreateInstancesFromSnapshot) ID() string {
 457  	return "OperationInputValidation"
 458  }
 459  
 460  func (m *validateOpCreateInstancesFromSnapshot) 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.(*CreateInstancesFromSnapshotInput)
 464  	if !ok {
 465  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 466  	}
 467  	if err := validateOpCreateInstancesFromSnapshotInput(input); err != nil {
 468  		return out, metadata, err
 469  	}
 470  	return next.HandleInitialize(ctx, in)
 471  }
 472  
 473  type validateOpCreateInstances struct {
 474  }
 475  
 476  func (*validateOpCreateInstances) ID() string {
 477  	return "OperationInputValidation"
 478  }
 479  
 480  func (m *validateOpCreateInstances) 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.(*CreateInstancesInput)
 484  	if !ok {
 485  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 486  	}
 487  	if err := validateOpCreateInstancesInput(input); err != nil {
 488  		return out, metadata, err
 489  	}
 490  	return next.HandleInitialize(ctx, in)
 491  }
 492  
 493  type validateOpCreateInstanceSnapshot struct {
 494  }
 495  
 496  func (*validateOpCreateInstanceSnapshot) ID() string {
 497  	return "OperationInputValidation"
 498  }
 499  
 500  func (m *validateOpCreateInstanceSnapshot) 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.(*CreateInstanceSnapshotInput)
 504  	if !ok {
 505  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 506  	}
 507  	if err := validateOpCreateInstanceSnapshotInput(input); err != nil {
 508  		return out, metadata, err
 509  	}
 510  	return next.HandleInitialize(ctx, in)
 511  }
 512  
 513  type validateOpCreateKeyPair struct {
 514  }
 515  
 516  func (*validateOpCreateKeyPair) ID() string {
 517  	return "OperationInputValidation"
 518  }
 519  
 520  func (m *validateOpCreateKeyPair) 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.(*CreateKeyPairInput)
 524  	if !ok {
 525  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 526  	}
 527  	if err := validateOpCreateKeyPairInput(input); err != nil {
 528  		return out, metadata, err
 529  	}
 530  	return next.HandleInitialize(ctx, in)
 531  }
 532  
 533  type validateOpCreateLoadBalancer struct {
 534  }
 535  
 536  func (*validateOpCreateLoadBalancer) ID() string {
 537  	return "OperationInputValidation"
 538  }
 539  
 540  func (m *validateOpCreateLoadBalancer) 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.(*CreateLoadBalancerInput)
 544  	if !ok {
 545  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 546  	}
 547  	if err := validateOpCreateLoadBalancerInput(input); err != nil {
 548  		return out, metadata, err
 549  	}
 550  	return next.HandleInitialize(ctx, in)
 551  }
 552  
 553  type validateOpCreateLoadBalancerTlsCertificate struct {
 554  }
 555  
 556  func (*validateOpCreateLoadBalancerTlsCertificate) ID() string {
 557  	return "OperationInputValidation"
 558  }
 559  
 560  func (m *validateOpCreateLoadBalancerTlsCertificate) 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.(*CreateLoadBalancerTlsCertificateInput)
 564  	if !ok {
 565  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 566  	}
 567  	if err := validateOpCreateLoadBalancerTlsCertificateInput(input); err != nil {
 568  		return out, metadata, err
 569  	}
 570  	return next.HandleInitialize(ctx, in)
 571  }
 572  
 573  type validateOpCreateRelationalDatabaseFromSnapshot struct {
 574  }
 575  
 576  func (*validateOpCreateRelationalDatabaseFromSnapshot) ID() string {
 577  	return "OperationInputValidation"
 578  }
 579  
 580  func (m *validateOpCreateRelationalDatabaseFromSnapshot) 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.(*CreateRelationalDatabaseFromSnapshotInput)
 584  	if !ok {
 585  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 586  	}
 587  	if err := validateOpCreateRelationalDatabaseFromSnapshotInput(input); err != nil {
 588  		return out, metadata, err
 589  	}
 590  	return next.HandleInitialize(ctx, in)
 591  }
 592  
 593  type validateOpCreateRelationalDatabase struct {
 594  }
 595  
 596  func (*validateOpCreateRelationalDatabase) ID() string {
 597  	return "OperationInputValidation"
 598  }
 599  
 600  func (m *validateOpCreateRelationalDatabase) 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.(*CreateRelationalDatabaseInput)
 604  	if !ok {
 605  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 606  	}
 607  	if err := validateOpCreateRelationalDatabaseInput(input); err != nil {
 608  		return out, metadata, err
 609  	}
 610  	return next.HandleInitialize(ctx, in)
 611  }
 612  
 613  type validateOpCreateRelationalDatabaseSnapshot struct {
 614  }
 615  
 616  func (*validateOpCreateRelationalDatabaseSnapshot) ID() string {
 617  	return "OperationInputValidation"
 618  }
 619  
 620  func (m *validateOpCreateRelationalDatabaseSnapshot) 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.(*CreateRelationalDatabaseSnapshotInput)
 624  	if !ok {
 625  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 626  	}
 627  	if err := validateOpCreateRelationalDatabaseSnapshotInput(input); err != nil {
 628  		return out, metadata, err
 629  	}
 630  	return next.HandleInitialize(ctx, in)
 631  }
 632  
 633  type validateOpDeleteAlarm struct {
 634  }
 635  
 636  func (*validateOpDeleteAlarm) ID() string {
 637  	return "OperationInputValidation"
 638  }
 639  
 640  func (m *validateOpDeleteAlarm) 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.(*DeleteAlarmInput)
 644  	if !ok {
 645  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 646  	}
 647  	if err := validateOpDeleteAlarmInput(input); err != nil {
 648  		return out, metadata, err
 649  	}
 650  	return next.HandleInitialize(ctx, in)
 651  }
 652  
 653  type validateOpDeleteAutoSnapshot struct {
 654  }
 655  
 656  func (*validateOpDeleteAutoSnapshot) ID() string {
 657  	return "OperationInputValidation"
 658  }
 659  
 660  func (m *validateOpDeleteAutoSnapshot) 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.(*DeleteAutoSnapshotInput)
 664  	if !ok {
 665  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 666  	}
 667  	if err := validateOpDeleteAutoSnapshotInput(input); err != nil {
 668  		return out, metadata, err
 669  	}
 670  	return next.HandleInitialize(ctx, in)
 671  }
 672  
 673  type validateOpDeleteBucketAccessKey struct {
 674  }
 675  
 676  func (*validateOpDeleteBucketAccessKey) ID() string {
 677  	return "OperationInputValidation"
 678  }
 679  
 680  func (m *validateOpDeleteBucketAccessKey) 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.(*DeleteBucketAccessKeyInput)
 684  	if !ok {
 685  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 686  	}
 687  	if err := validateOpDeleteBucketAccessKeyInput(input); err != nil {
 688  		return out, metadata, err
 689  	}
 690  	return next.HandleInitialize(ctx, in)
 691  }
 692  
 693  type validateOpDeleteBucket struct {
 694  }
 695  
 696  func (*validateOpDeleteBucket) ID() string {
 697  	return "OperationInputValidation"
 698  }
 699  
 700  func (m *validateOpDeleteBucket) 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.(*DeleteBucketInput)
 704  	if !ok {
 705  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 706  	}
 707  	if err := validateOpDeleteBucketInput(input); err != nil {
 708  		return out, metadata, err
 709  	}
 710  	return next.HandleInitialize(ctx, in)
 711  }
 712  
 713  type validateOpDeleteCertificate struct {
 714  }
 715  
 716  func (*validateOpDeleteCertificate) ID() string {
 717  	return "OperationInputValidation"
 718  }
 719  
 720  func (m *validateOpDeleteCertificate) 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.(*DeleteCertificateInput)
 724  	if !ok {
 725  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 726  	}
 727  	if err := validateOpDeleteCertificateInput(input); err != nil {
 728  		return out, metadata, err
 729  	}
 730  	return next.HandleInitialize(ctx, in)
 731  }
 732  
 733  type validateOpDeleteContactMethod struct {
 734  }
 735  
 736  func (*validateOpDeleteContactMethod) ID() string {
 737  	return "OperationInputValidation"
 738  }
 739  
 740  func (m *validateOpDeleteContactMethod) 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.(*DeleteContactMethodInput)
 744  	if !ok {
 745  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 746  	}
 747  	if err := validateOpDeleteContactMethodInput(input); err != nil {
 748  		return out, metadata, err
 749  	}
 750  	return next.HandleInitialize(ctx, in)
 751  }
 752  
 753  type validateOpDeleteContainerImage struct {
 754  }
 755  
 756  func (*validateOpDeleteContainerImage) ID() string {
 757  	return "OperationInputValidation"
 758  }
 759  
 760  func (m *validateOpDeleteContainerImage) 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.(*DeleteContainerImageInput)
 764  	if !ok {
 765  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 766  	}
 767  	if err := validateOpDeleteContainerImageInput(input); err != nil {
 768  		return out, metadata, err
 769  	}
 770  	return next.HandleInitialize(ctx, in)
 771  }
 772  
 773  type validateOpDeleteContainerService struct {
 774  }
 775  
 776  func (*validateOpDeleteContainerService) ID() string {
 777  	return "OperationInputValidation"
 778  }
 779  
 780  func (m *validateOpDeleteContainerService) 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.(*DeleteContainerServiceInput)
 784  	if !ok {
 785  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 786  	}
 787  	if err := validateOpDeleteContainerServiceInput(input); err != nil {
 788  		return out, metadata, err
 789  	}
 790  	return next.HandleInitialize(ctx, in)
 791  }
 792  
 793  type validateOpDeleteDisk struct {
 794  }
 795  
 796  func (*validateOpDeleteDisk) ID() string {
 797  	return "OperationInputValidation"
 798  }
 799  
 800  func (m *validateOpDeleteDisk) 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.(*DeleteDiskInput)
 804  	if !ok {
 805  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 806  	}
 807  	if err := validateOpDeleteDiskInput(input); err != nil {
 808  		return out, metadata, err
 809  	}
 810  	return next.HandleInitialize(ctx, in)
 811  }
 812  
 813  type validateOpDeleteDiskSnapshot struct {
 814  }
 815  
 816  func (*validateOpDeleteDiskSnapshot) ID() string {
 817  	return "OperationInputValidation"
 818  }
 819  
 820  func (m *validateOpDeleteDiskSnapshot) 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.(*DeleteDiskSnapshotInput)
 824  	if !ok {
 825  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 826  	}
 827  	if err := validateOpDeleteDiskSnapshotInput(input); err != nil {
 828  		return out, metadata, err
 829  	}
 830  	return next.HandleInitialize(ctx, in)
 831  }
 832  
 833  type validateOpDeleteDomainEntry struct {
 834  }
 835  
 836  func (*validateOpDeleteDomainEntry) ID() string {
 837  	return "OperationInputValidation"
 838  }
 839  
 840  func (m *validateOpDeleteDomainEntry) 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.(*DeleteDomainEntryInput)
 844  	if !ok {
 845  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 846  	}
 847  	if err := validateOpDeleteDomainEntryInput(input); err != nil {
 848  		return out, metadata, err
 849  	}
 850  	return next.HandleInitialize(ctx, in)
 851  }
 852  
 853  type validateOpDeleteDomain struct {
 854  }
 855  
 856  func (*validateOpDeleteDomain) ID() string {
 857  	return "OperationInputValidation"
 858  }
 859  
 860  func (m *validateOpDeleteDomain) 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.(*DeleteDomainInput)
 864  	if !ok {
 865  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 866  	}
 867  	if err := validateOpDeleteDomainInput(input); err != nil {
 868  		return out, metadata, err
 869  	}
 870  	return next.HandleInitialize(ctx, in)
 871  }
 872  
 873  type validateOpDeleteInstance struct {
 874  }
 875  
 876  func (*validateOpDeleteInstance) ID() string {
 877  	return "OperationInputValidation"
 878  }
 879  
 880  func (m *validateOpDeleteInstance) 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.(*DeleteInstanceInput)
 884  	if !ok {
 885  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 886  	}
 887  	if err := validateOpDeleteInstanceInput(input); err != nil {
 888  		return out, metadata, err
 889  	}
 890  	return next.HandleInitialize(ctx, in)
 891  }
 892  
 893  type validateOpDeleteInstanceSnapshot struct {
 894  }
 895  
 896  func (*validateOpDeleteInstanceSnapshot) ID() string {
 897  	return "OperationInputValidation"
 898  }
 899  
 900  func (m *validateOpDeleteInstanceSnapshot) 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.(*DeleteInstanceSnapshotInput)
 904  	if !ok {
 905  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 906  	}
 907  	if err := validateOpDeleteInstanceSnapshotInput(input); err != nil {
 908  		return out, metadata, err
 909  	}
 910  	return next.HandleInitialize(ctx, in)
 911  }
 912  
 913  type validateOpDeleteKeyPair struct {
 914  }
 915  
 916  func (*validateOpDeleteKeyPair) ID() string {
 917  	return "OperationInputValidation"
 918  }
 919  
 920  func (m *validateOpDeleteKeyPair) 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.(*DeleteKeyPairInput)
 924  	if !ok {
 925  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 926  	}
 927  	if err := validateOpDeleteKeyPairInput(input); err != nil {
 928  		return out, metadata, err
 929  	}
 930  	return next.HandleInitialize(ctx, in)
 931  }
 932  
 933  type validateOpDeleteKnownHostKeys struct {
 934  }
 935  
 936  func (*validateOpDeleteKnownHostKeys) ID() string {
 937  	return "OperationInputValidation"
 938  }
 939  
 940  func (m *validateOpDeleteKnownHostKeys) 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.(*DeleteKnownHostKeysInput)
 944  	if !ok {
 945  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 946  	}
 947  	if err := validateOpDeleteKnownHostKeysInput(input); err != nil {
 948  		return out, metadata, err
 949  	}
 950  	return next.HandleInitialize(ctx, in)
 951  }
 952  
 953  type validateOpDeleteLoadBalancer struct {
 954  }
 955  
 956  func (*validateOpDeleteLoadBalancer) ID() string {
 957  	return "OperationInputValidation"
 958  }
 959  
 960  func (m *validateOpDeleteLoadBalancer) 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.(*DeleteLoadBalancerInput)
 964  	if !ok {
 965  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 966  	}
 967  	if err := validateOpDeleteLoadBalancerInput(input); err != nil {
 968  		return out, metadata, err
 969  	}
 970  	return next.HandleInitialize(ctx, in)
 971  }
 972  
 973  type validateOpDeleteLoadBalancerTlsCertificate struct {
 974  }
 975  
 976  func (*validateOpDeleteLoadBalancerTlsCertificate) ID() string {
 977  	return "OperationInputValidation"
 978  }
 979  
 980  func (m *validateOpDeleteLoadBalancerTlsCertificate) 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.(*DeleteLoadBalancerTlsCertificateInput)
 984  	if !ok {
 985  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
 986  	}
 987  	if err := validateOpDeleteLoadBalancerTlsCertificateInput(input); err != nil {
 988  		return out, metadata, err
 989  	}
 990  	return next.HandleInitialize(ctx, in)
 991  }
 992  
 993  type validateOpDeleteRelationalDatabase struct {
 994  }
 995  
 996  func (*validateOpDeleteRelationalDatabase) ID() string {
 997  	return "OperationInputValidation"
 998  }
 999  
1000  func (m *validateOpDeleteRelationalDatabase) 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.(*DeleteRelationalDatabaseInput)
1004  	if !ok {
1005  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006  	}
1007  	if err := validateOpDeleteRelationalDatabaseInput(input); err != nil {
1008  		return out, metadata, err
1009  	}
1010  	return next.HandleInitialize(ctx, in)
1011  }
1012  
1013  type validateOpDeleteRelationalDatabaseSnapshot struct {
1014  }
1015  
1016  func (*validateOpDeleteRelationalDatabaseSnapshot) ID() string {
1017  	return "OperationInputValidation"
1018  }
1019  
1020  func (m *validateOpDeleteRelationalDatabaseSnapshot) 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.(*DeleteRelationalDatabaseSnapshotInput)
1024  	if !ok {
1025  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026  	}
1027  	if err := validateOpDeleteRelationalDatabaseSnapshotInput(input); err != nil {
1028  		return out, metadata, err
1029  	}
1030  	return next.HandleInitialize(ctx, in)
1031  }
1032  
1033  type validateOpDetachCertificateFromDistribution struct {
1034  }
1035  
1036  func (*validateOpDetachCertificateFromDistribution) ID() string {
1037  	return "OperationInputValidation"
1038  }
1039  
1040  func (m *validateOpDetachCertificateFromDistribution) 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.(*DetachCertificateFromDistributionInput)
1044  	if !ok {
1045  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046  	}
1047  	if err := validateOpDetachCertificateFromDistributionInput(input); err != nil {
1048  		return out, metadata, err
1049  	}
1050  	return next.HandleInitialize(ctx, in)
1051  }
1052  
1053  type validateOpDetachDisk struct {
1054  }
1055  
1056  func (*validateOpDetachDisk) ID() string {
1057  	return "OperationInputValidation"
1058  }
1059  
1060  func (m *validateOpDetachDisk) 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.(*DetachDiskInput)
1064  	if !ok {
1065  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066  	}
1067  	if err := validateOpDetachDiskInput(input); err != nil {
1068  		return out, metadata, err
1069  	}
1070  	return next.HandleInitialize(ctx, in)
1071  }
1072  
1073  type validateOpDetachInstancesFromLoadBalancer struct {
1074  }
1075  
1076  func (*validateOpDetachInstancesFromLoadBalancer) ID() string {
1077  	return "OperationInputValidation"
1078  }
1079  
1080  func (m *validateOpDetachInstancesFromLoadBalancer) 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.(*DetachInstancesFromLoadBalancerInput)
1084  	if !ok {
1085  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086  	}
1087  	if err := validateOpDetachInstancesFromLoadBalancerInput(input); err != nil {
1088  		return out, metadata, err
1089  	}
1090  	return next.HandleInitialize(ctx, in)
1091  }
1092  
1093  type validateOpDetachStaticIp struct {
1094  }
1095  
1096  func (*validateOpDetachStaticIp) ID() string {
1097  	return "OperationInputValidation"
1098  }
1099  
1100  func (m *validateOpDetachStaticIp) 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.(*DetachStaticIpInput)
1104  	if !ok {
1105  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106  	}
1107  	if err := validateOpDetachStaticIpInput(input); err != nil {
1108  		return out, metadata, err
1109  	}
1110  	return next.HandleInitialize(ctx, in)
1111  }
1112  
1113  type validateOpDisableAddOn struct {
1114  }
1115  
1116  func (*validateOpDisableAddOn) ID() string {
1117  	return "OperationInputValidation"
1118  }
1119  
1120  func (m *validateOpDisableAddOn) 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.(*DisableAddOnInput)
1124  	if !ok {
1125  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126  	}
1127  	if err := validateOpDisableAddOnInput(input); err != nil {
1128  		return out, metadata, err
1129  	}
1130  	return next.HandleInitialize(ctx, in)
1131  }
1132  
1133  type validateOpEnableAddOn struct {
1134  }
1135  
1136  func (*validateOpEnableAddOn) ID() string {
1137  	return "OperationInputValidation"
1138  }
1139  
1140  func (m *validateOpEnableAddOn) 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.(*EnableAddOnInput)
1144  	if !ok {
1145  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146  	}
1147  	if err := validateOpEnableAddOnInput(input); err != nil {
1148  		return out, metadata, err
1149  	}
1150  	return next.HandleInitialize(ctx, in)
1151  }
1152  
1153  type validateOpExportSnapshot struct {
1154  }
1155  
1156  func (*validateOpExportSnapshot) ID() string {
1157  	return "OperationInputValidation"
1158  }
1159  
1160  func (m *validateOpExportSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162  ) {
1163  	input, ok := in.Parameters.(*ExportSnapshotInput)
1164  	if !ok {
1165  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166  	}
1167  	if err := validateOpExportSnapshotInput(input); err != nil {
1168  		return out, metadata, err
1169  	}
1170  	return next.HandleInitialize(ctx, in)
1171  }
1172  
1173  type validateOpGetAutoSnapshots struct {
1174  }
1175  
1176  func (*validateOpGetAutoSnapshots) ID() string {
1177  	return "OperationInputValidation"
1178  }
1179  
1180  func (m *validateOpGetAutoSnapshots) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182  ) {
1183  	input, ok := in.Parameters.(*GetAutoSnapshotsInput)
1184  	if !ok {
1185  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186  	}
1187  	if err := validateOpGetAutoSnapshotsInput(input); err != nil {
1188  		return out, metadata, err
1189  	}
1190  	return next.HandleInitialize(ctx, in)
1191  }
1192  
1193  type validateOpGetBucketAccessKeys struct {
1194  }
1195  
1196  func (*validateOpGetBucketAccessKeys) ID() string {
1197  	return "OperationInputValidation"
1198  }
1199  
1200  func (m *validateOpGetBucketAccessKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202  ) {
1203  	input, ok := in.Parameters.(*GetBucketAccessKeysInput)
1204  	if !ok {
1205  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206  	}
1207  	if err := validateOpGetBucketAccessKeysInput(input); err != nil {
1208  		return out, metadata, err
1209  	}
1210  	return next.HandleInitialize(ctx, in)
1211  }
1212  
1213  type validateOpGetBucketMetricData struct {
1214  }
1215  
1216  func (*validateOpGetBucketMetricData) ID() string {
1217  	return "OperationInputValidation"
1218  }
1219  
1220  func (m *validateOpGetBucketMetricData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222  ) {
1223  	input, ok := in.Parameters.(*GetBucketMetricDataInput)
1224  	if !ok {
1225  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226  	}
1227  	if err := validateOpGetBucketMetricDataInput(input); err != nil {
1228  		return out, metadata, err
1229  	}
1230  	return next.HandleInitialize(ctx, in)
1231  }
1232  
1233  type validateOpGetContainerImages struct {
1234  }
1235  
1236  func (*validateOpGetContainerImages) ID() string {
1237  	return "OperationInputValidation"
1238  }
1239  
1240  func (m *validateOpGetContainerImages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242  ) {
1243  	input, ok := in.Parameters.(*GetContainerImagesInput)
1244  	if !ok {
1245  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246  	}
1247  	if err := validateOpGetContainerImagesInput(input); err != nil {
1248  		return out, metadata, err
1249  	}
1250  	return next.HandleInitialize(ctx, in)
1251  }
1252  
1253  type validateOpGetContainerLog struct {
1254  }
1255  
1256  func (*validateOpGetContainerLog) ID() string {
1257  	return "OperationInputValidation"
1258  }
1259  
1260  func (m *validateOpGetContainerLog) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262  ) {
1263  	input, ok := in.Parameters.(*GetContainerLogInput)
1264  	if !ok {
1265  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266  	}
1267  	if err := validateOpGetContainerLogInput(input); err != nil {
1268  		return out, metadata, err
1269  	}
1270  	return next.HandleInitialize(ctx, in)
1271  }
1272  
1273  type validateOpGetContainerServiceDeployments struct {
1274  }
1275  
1276  func (*validateOpGetContainerServiceDeployments) ID() string {
1277  	return "OperationInputValidation"
1278  }
1279  
1280  func (m *validateOpGetContainerServiceDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282  ) {
1283  	input, ok := in.Parameters.(*GetContainerServiceDeploymentsInput)
1284  	if !ok {
1285  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286  	}
1287  	if err := validateOpGetContainerServiceDeploymentsInput(input); err != nil {
1288  		return out, metadata, err
1289  	}
1290  	return next.HandleInitialize(ctx, in)
1291  }
1292  
1293  type validateOpGetContainerServiceMetricData struct {
1294  }
1295  
1296  func (*validateOpGetContainerServiceMetricData) ID() string {
1297  	return "OperationInputValidation"
1298  }
1299  
1300  func (m *validateOpGetContainerServiceMetricData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302  ) {
1303  	input, ok := in.Parameters.(*GetContainerServiceMetricDataInput)
1304  	if !ok {
1305  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306  	}
1307  	if err := validateOpGetContainerServiceMetricDataInput(input); err != nil {
1308  		return out, metadata, err
1309  	}
1310  	return next.HandleInitialize(ctx, in)
1311  }
1312  
1313  type validateOpGetCostEstimate struct {
1314  }
1315  
1316  func (*validateOpGetCostEstimate) ID() string {
1317  	return "OperationInputValidation"
1318  }
1319  
1320  func (m *validateOpGetCostEstimate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322  ) {
1323  	input, ok := in.Parameters.(*GetCostEstimateInput)
1324  	if !ok {
1325  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326  	}
1327  	if err := validateOpGetCostEstimateInput(input); err != nil {
1328  		return out, metadata, err
1329  	}
1330  	return next.HandleInitialize(ctx, in)
1331  }
1332  
1333  type validateOpGetDisk struct {
1334  }
1335  
1336  func (*validateOpGetDisk) ID() string {
1337  	return "OperationInputValidation"
1338  }
1339  
1340  func (m *validateOpGetDisk) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342  ) {
1343  	input, ok := in.Parameters.(*GetDiskInput)
1344  	if !ok {
1345  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346  	}
1347  	if err := validateOpGetDiskInput(input); err != nil {
1348  		return out, metadata, err
1349  	}
1350  	return next.HandleInitialize(ctx, in)
1351  }
1352  
1353  type validateOpGetDiskSnapshot struct {
1354  }
1355  
1356  func (*validateOpGetDiskSnapshot) ID() string {
1357  	return "OperationInputValidation"
1358  }
1359  
1360  func (m *validateOpGetDiskSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362  ) {
1363  	input, ok := in.Parameters.(*GetDiskSnapshotInput)
1364  	if !ok {
1365  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366  	}
1367  	if err := validateOpGetDiskSnapshotInput(input); err != nil {
1368  		return out, metadata, err
1369  	}
1370  	return next.HandleInitialize(ctx, in)
1371  }
1372  
1373  type validateOpGetDistributionMetricData struct {
1374  }
1375  
1376  func (*validateOpGetDistributionMetricData) ID() string {
1377  	return "OperationInputValidation"
1378  }
1379  
1380  func (m *validateOpGetDistributionMetricData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382  ) {
1383  	input, ok := in.Parameters.(*GetDistributionMetricDataInput)
1384  	if !ok {
1385  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386  	}
1387  	if err := validateOpGetDistributionMetricDataInput(input); err != nil {
1388  		return out, metadata, err
1389  	}
1390  	return next.HandleInitialize(ctx, in)
1391  }
1392  
1393  type validateOpGetDomain struct {
1394  }
1395  
1396  func (*validateOpGetDomain) ID() string {
1397  	return "OperationInputValidation"
1398  }
1399  
1400  func (m *validateOpGetDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1401  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1402  ) {
1403  	input, ok := in.Parameters.(*GetDomainInput)
1404  	if !ok {
1405  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406  	}
1407  	if err := validateOpGetDomainInput(input); err != nil {
1408  		return out, metadata, err
1409  	}
1410  	return next.HandleInitialize(ctx, in)
1411  }
1412  
1413  type validateOpGetInstanceAccessDetails struct {
1414  }
1415  
1416  func (*validateOpGetInstanceAccessDetails) ID() string {
1417  	return "OperationInputValidation"
1418  }
1419  
1420  func (m *validateOpGetInstanceAccessDetails) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1421  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1422  ) {
1423  	input, ok := in.Parameters.(*GetInstanceAccessDetailsInput)
1424  	if !ok {
1425  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426  	}
1427  	if err := validateOpGetInstanceAccessDetailsInput(input); err != nil {
1428  		return out, metadata, err
1429  	}
1430  	return next.HandleInitialize(ctx, in)
1431  }
1432  
1433  type validateOpGetInstance struct {
1434  }
1435  
1436  func (*validateOpGetInstance) ID() string {
1437  	return "OperationInputValidation"
1438  }
1439  
1440  func (m *validateOpGetInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1441  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1442  ) {
1443  	input, ok := in.Parameters.(*GetInstanceInput)
1444  	if !ok {
1445  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446  	}
1447  	if err := validateOpGetInstanceInput(input); err != nil {
1448  		return out, metadata, err
1449  	}
1450  	return next.HandleInitialize(ctx, in)
1451  }
1452  
1453  type validateOpGetInstanceMetricData struct {
1454  }
1455  
1456  func (*validateOpGetInstanceMetricData) ID() string {
1457  	return "OperationInputValidation"
1458  }
1459  
1460  func (m *validateOpGetInstanceMetricData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1461  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1462  ) {
1463  	input, ok := in.Parameters.(*GetInstanceMetricDataInput)
1464  	if !ok {
1465  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466  	}
1467  	if err := validateOpGetInstanceMetricDataInput(input); err != nil {
1468  		return out, metadata, err
1469  	}
1470  	return next.HandleInitialize(ctx, in)
1471  }
1472  
1473  type validateOpGetInstancePortStates struct {
1474  }
1475  
1476  func (*validateOpGetInstancePortStates) ID() string {
1477  	return "OperationInputValidation"
1478  }
1479  
1480  func (m *validateOpGetInstancePortStates) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1481  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1482  ) {
1483  	input, ok := in.Parameters.(*GetInstancePortStatesInput)
1484  	if !ok {
1485  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486  	}
1487  	if err := validateOpGetInstancePortStatesInput(input); err != nil {
1488  		return out, metadata, err
1489  	}
1490  	return next.HandleInitialize(ctx, in)
1491  }
1492  
1493  type validateOpGetInstanceSnapshot struct {
1494  }
1495  
1496  func (*validateOpGetInstanceSnapshot) ID() string {
1497  	return "OperationInputValidation"
1498  }
1499  
1500  func (m *validateOpGetInstanceSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1501  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1502  ) {
1503  	input, ok := in.Parameters.(*GetInstanceSnapshotInput)
1504  	if !ok {
1505  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506  	}
1507  	if err := validateOpGetInstanceSnapshotInput(input); err != nil {
1508  		return out, metadata, err
1509  	}
1510  	return next.HandleInitialize(ctx, in)
1511  }
1512  
1513  type validateOpGetInstanceState struct {
1514  }
1515  
1516  func (*validateOpGetInstanceState) ID() string {
1517  	return "OperationInputValidation"
1518  }
1519  
1520  func (m *validateOpGetInstanceState) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1521  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1522  ) {
1523  	input, ok := in.Parameters.(*GetInstanceStateInput)
1524  	if !ok {
1525  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526  	}
1527  	if err := validateOpGetInstanceStateInput(input); err != nil {
1528  		return out, metadata, err
1529  	}
1530  	return next.HandleInitialize(ctx, in)
1531  }
1532  
1533  type validateOpGetKeyPair struct {
1534  }
1535  
1536  func (*validateOpGetKeyPair) ID() string {
1537  	return "OperationInputValidation"
1538  }
1539  
1540  func (m *validateOpGetKeyPair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1541  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1542  ) {
1543  	input, ok := in.Parameters.(*GetKeyPairInput)
1544  	if !ok {
1545  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546  	}
1547  	if err := validateOpGetKeyPairInput(input); err != nil {
1548  		return out, metadata, err
1549  	}
1550  	return next.HandleInitialize(ctx, in)
1551  }
1552  
1553  type validateOpGetLoadBalancer struct {
1554  }
1555  
1556  func (*validateOpGetLoadBalancer) ID() string {
1557  	return "OperationInputValidation"
1558  }
1559  
1560  func (m *validateOpGetLoadBalancer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1561  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1562  ) {
1563  	input, ok := in.Parameters.(*GetLoadBalancerInput)
1564  	if !ok {
1565  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1566  	}
1567  	if err := validateOpGetLoadBalancerInput(input); err != nil {
1568  		return out, metadata, err
1569  	}
1570  	return next.HandleInitialize(ctx, in)
1571  }
1572  
1573  type validateOpGetLoadBalancerMetricData struct {
1574  }
1575  
1576  func (*validateOpGetLoadBalancerMetricData) ID() string {
1577  	return "OperationInputValidation"
1578  }
1579  
1580  func (m *validateOpGetLoadBalancerMetricData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1581  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1582  ) {
1583  	input, ok := in.Parameters.(*GetLoadBalancerMetricDataInput)
1584  	if !ok {
1585  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1586  	}
1587  	if err := validateOpGetLoadBalancerMetricDataInput(input); err != nil {
1588  		return out, metadata, err
1589  	}
1590  	return next.HandleInitialize(ctx, in)
1591  }
1592  
1593  type validateOpGetLoadBalancerTlsCertificates struct {
1594  }
1595  
1596  func (*validateOpGetLoadBalancerTlsCertificates) ID() string {
1597  	return "OperationInputValidation"
1598  }
1599  
1600  func (m *validateOpGetLoadBalancerTlsCertificates) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1601  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1602  ) {
1603  	input, ok := in.Parameters.(*GetLoadBalancerTlsCertificatesInput)
1604  	if !ok {
1605  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1606  	}
1607  	if err := validateOpGetLoadBalancerTlsCertificatesInput(input); err != nil {
1608  		return out, metadata, err
1609  	}
1610  	return next.HandleInitialize(ctx, in)
1611  }
1612  
1613  type validateOpGetOperation struct {
1614  }
1615  
1616  func (*validateOpGetOperation) ID() string {
1617  	return "OperationInputValidation"
1618  }
1619  
1620  func (m *validateOpGetOperation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1621  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1622  ) {
1623  	input, ok := in.Parameters.(*GetOperationInput)
1624  	if !ok {
1625  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1626  	}
1627  	if err := validateOpGetOperationInput(input); err != nil {
1628  		return out, metadata, err
1629  	}
1630  	return next.HandleInitialize(ctx, in)
1631  }
1632  
1633  type validateOpGetOperationsForResource struct {
1634  }
1635  
1636  func (*validateOpGetOperationsForResource) ID() string {
1637  	return "OperationInputValidation"
1638  }
1639  
1640  func (m *validateOpGetOperationsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1641  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1642  ) {
1643  	input, ok := in.Parameters.(*GetOperationsForResourceInput)
1644  	if !ok {
1645  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1646  	}
1647  	if err := validateOpGetOperationsForResourceInput(input); err != nil {
1648  		return out, metadata, err
1649  	}
1650  	return next.HandleInitialize(ctx, in)
1651  }
1652  
1653  type validateOpGetRelationalDatabaseEvents struct {
1654  }
1655  
1656  func (*validateOpGetRelationalDatabaseEvents) ID() string {
1657  	return "OperationInputValidation"
1658  }
1659  
1660  func (m *validateOpGetRelationalDatabaseEvents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1661  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1662  ) {
1663  	input, ok := in.Parameters.(*GetRelationalDatabaseEventsInput)
1664  	if !ok {
1665  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1666  	}
1667  	if err := validateOpGetRelationalDatabaseEventsInput(input); err != nil {
1668  		return out, metadata, err
1669  	}
1670  	return next.HandleInitialize(ctx, in)
1671  }
1672  
1673  type validateOpGetRelationalDatabase struct {
1674  }
1675  
1676  func (*validateOpGetRelationalDatabase) ID() string {
1677  	return "OperationInputValidation"
1678  }
1679  
1680  func (m *validateOpGetRelationalDatabase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1681  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1682  ) {
1683  	input, ok := in.Parameters.(*GetRelationalDatabaseInput)
1684  	if !ok {
1685  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1686  	}
1687  	if err := validateOpGetRelationalDatabaseInput(input); err != nil {
1688  		return out, metadata, err
1689  	}
1690  	return next.HandleInitialize(ctx, in)
1691  }
1692  
1693  type validateOpGetRelationalDatabaseLogEvents struct {
1694  }
1695  
1696  func (*validateOpGetRelationalDatabaseLogEvents) ID() string {
1697  	return "OperationInputValidation"
1698  }
1699  
1700  func (m *validateOpGetRelationalDatabaseLogEvents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1701  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1702  ) {
1703  	input, ok := in.Parameters.(*GetRelationalDatabaseLogEventsInput)
1704  	if !ok {
1705  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1706  	}
1707  	if err := validateOpGetRelationalDatabaseLogEventsInput(input); err != nil {
1708  		return out, metadata, err
1709  	}
1710  	return next.HandleInitialize(ctx, in)
1711  }
1712  
1713  type validateOpGetRelationalDatabaseLogStreams struct {
1714  }
1715  
1716  func (*validateOpGetRelationalDatabaseLogStreams) ID() string {
1717  	return "OperationInputValidation"
1718  }
1719  
1720  func (m *validateOpGetRelationalDatabaseLogStreams) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1721  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1722  ) {
1723  	input, ok := in.Parameters.(*GetRelationalDatabaseLogStreamsInput)
1724  	if !ok {
1725  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1726  	}
1727  	if err := validateOpGetRelationalDatabaseLogStreamsInput(input); err != nil {
1728  		return out, metadata, err
1729  	}
1730  	return next.HandleInitialize(ctx, in)
1731  }
1732  
1733  type validateOpGetRelationalDatabaseMasterUserPassword struct {
1734  }
1735  
1736  func (*validateOpGetRelationalDatabaseMasterUserPassword) ID() string {
1737  	return "OperationInputValidation"
1738  }
1739  
1740  func (m *validateOpGetRelationalDatabaseMasterUserPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1741  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1742  ) {
1743  	input, ok := in.Parameters.(*GetRelationalDatabaseMasterUserPasswordInput)
1744  	if !ok {
1745  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1746  	}
1747  	if err := validateOpGetRelationalDatabaseMasterUserPasswordInput(input); err != nil {
1748  		return out, metadata, err
1749  	}
1750  	return next.HandleInitialize(ctx, in)
1751  }
1752  
1753  type validateOpGetRelationalDatabaseMetricData struct {
1754  }
1755  
1756  func (*validateOpGetRelationalDatabaseMetricData) ID() string {
1757  	return "OperationInputValidation"
1758  }
1759  
1760  func (m *validateOpGetRelationalDatabaseMetricData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1761  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1762  ) {
1763  	input, ok := in.Parameters.(*GetRelationalDatabaseMetricDataInput)
1764  	if !ok {
1765  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1766  	}
1767  	if err := validateOpGetRelationalDatabaseMetricDataInput(input); err != nil {
1768  		return out, metadata, err
1769  	}
1770  	return next.HandleInitialize(ctx, in)
1771  }
1772  
1773  type validateOpGetRelationalDatabaseParameters struct {
1774  }
1775  
1776  func (*validateOpGetRelationalDatabaseParameters) ID() string {
1777  	return "OperationInputValidation"
1778  }
1779  
1780  func (m *validateOpGetRelationalDatabaseParameters) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1781  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1782  ) {
1783  	input, ok := in.Parameters.(*GetRelationalDatabaseParametersInput)
1784  	if !ok {
1785  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1786  	}
1787  	if err := validateOpGetRelationalDatabaseParametersInput(input); err != nil {
1788  		return out, metadata, err
1789  	}
1790  	return next.HandleInitialize(ctx, in)
1791  }
1792  
1793  type validateOpGetRelationalDatabaseSnapshot struct {
1794  }
1795  
1796  func (*validateOpGetRelationalDatabaseSnapshot) ID() string {
1797  	return "OperationInputValidation"
1798  }
1799  
1800  func (m *validateOpGetRelationalDatabaseSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1801  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1802  ) {
1803  	input, ok := in.Parameters.(*GetRelationalDatabaseSnapshotInput)
1804  	if !ok {
1805  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1806  	}
1807  	if err := validateOpGetRelationalDatabaseSnapshotInput(input); err != nil {
1808  		return out, metadata, err
1809  	}
1810  	return next.HandleInitialize(ctx, in)
1811  }
1812  
1813  type validateOpGetSetupHistory struct {
1814  }
1815  
1816  func (*validateOpGetSetupHistory) ID() string {
1817  	return "OperationInputValidation"
1818  }
1819  
1820  func (m *validateOpGetSetupHistory) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1821  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1822  ) {
1823  	input, ok := in.Parameters.(*GetSetupHistoryInput)
1824  	if !ok {
1825  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1826  	}
1827  	if err := validateOpGetSetupHistoryInput(input); err != nil {
1828  		return out, metadata, err
1829  	}
1830  	return next.HandleInitialize(ctx, in)
1831  }
1832  
1833  type validateOpGetStaticIp struct {
1834  }
1835  
1836  func (*validateOpGetStaticIp) ID() string {
1837  	return "OperationInputValidation"
1838  }
1839  
1840  func (m *validateOpGetStaticIp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1841  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1842  ) {
1843  	input, ok := in.Parameters.(*GetStaticIpInput)
1844  	if !ok {
1845  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1846  	}
1847  	if err := validateOpGetStaticIpInput(input); err != nil {
1848  		return out, metadata, err
1849  	}
1850  	return next.HandleInitialize(ctx, in)
1851  }
1852  
1853  type validateOpImportKeyPair struct {
1854  }
1855  
1856  func (*validateOpImportKeyPair) ID() string {
1857  	return "OperationInputValidation"
1858  }
1859  
1860  func (m *validateOpImportKeyPair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1861  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1862  ) {
1863  	input, ok := in.Parameters.(*ImportKeyPairInput)
1864  	if !ok {
1865  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1866  	}
1867  	if err := validateOpImportKeyPairInput(input); err != nil {
1868  		return out, metadata, err
1869  	}
1870  	return next.HandleInitialize(ctx, in)
1871  }
1872  
1873  type validateOpOpenInstancePublicPorts struct {
1874  }
1875  
1876  func (*validateOpOpenInstancePublicPorts) ID() string {
1877  	return "OperationInputValidation"
1878  }
1879  
1880  func (m *validateOpOpenInstancePublicPorts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1881  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1882  ) {
1883  	input, ok := in.Parameters.(*OpenInstancePublicPortsInput)
1884  	if !ok {
1885  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1886  	}
1887  	if err := validateOpOpenInstancePublicPortsInput(input); err != nil {
1888  		return out, metadata, err
1889  	}
1890  	return next.HandleInitialize(ctx, in)
1891  }
1892  
1893  type validateOpPutAlarm struct {
1894  }
1895  
1896  func (*validateOpPutAlarm) ID() string {
1897  	return "OperationInputValidation"
1898  }
1899  
1900  func (m *validateOpPutAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1901  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1902  ) {
1903  	input, ok := in.Parameters.(*PutAlarmInput)
1904  	if !ok {
1905  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1906  	}
1907  	if err := validateOpPutAlarmInput(input); err != nil {
1908  		return out, metadata, err
1909  	}
1910  	return next.HandleInitialize(ctx, in)
1911  }
1912  
1913  type validateOpPutInstancePublicPorts struct {
1914  }
1915  
1916  func (*validateOpPutInstancePublicPorts) ID() string {
1917  	return "OperationInputValidation"
1918  }
1919  
1920  func (m *validateOpPutInstancePublicPorts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1921  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1922  ) {
1923  	input, ok := in.Parameters.(*PutInstancePublicPortsInput)
1924  	if !ok {
1925  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1926  	}
1927  	if err := validateOpPutInstancePublicPortsInput(input); err != nil {
1928  		return out, metadata, err
1929  	}
1930  	return next.HandleInitialize(ctx, in)
1931  }
1932  
1933  type validateOpRebootInstance struct {
1934  }
1935  
1936  func (*validateOpRebootInstance) ID() string {
1937  	return "OperationInputValidation"
1938  }
1939  
1940  func (m *validateOpRebootInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1941  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1942  ) {
1943  	input, ok := in.Parameters.(*RebootInstanceInput)
1944  	if !ok {
1945  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1946  	}
1947  	if err := validateOpRebootInstanceInput(input); err != nil {
1948  		return out, metadata, err
1949  	}
1950  	return next.HandleInitialize(ctx, in)
1951  }
1952  
1953  type validateOpRebootRelationalDatabase struct {
1954  }
1955  
1956  func (*validateOpRebootRelationalDatabase) ID() string {
1957  	return "OperationInputValidation"
1958  }
1959  
1960  func (m *validateOpRebootRelationalDatabase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1961  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1962  ) {
1963  	input, ok := in.Parameters.(*RebootRelationalDatabaseInput)
1964  	if !ok {
1965  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1966  	}
1967  	if err := validateOpRebootRelationalDatabaseInput(input); err != nil {
1968  		return out, metadata, err
1969  	}
1970  	return next.HandleInitialize(ctx, in)
1971  }
1972  
1973  type validateOpRegisterContainerImage struct {
1974  }
1975  
1976  func (*validateOpRegisterContainerImage) ID() string {
1977  	return "OperationInputValidation"
1978  }
1979  
1980  func (m *validateOpRegisterContainerImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1981  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1982  ) {
1983  	input, ok := in.Parameters.(*RegisterContainerImageInput)
1984  	if !ok {
1985  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1986  	}
1987  	if err := validateOpRegisterContainerImageInput(input); err != nil {
1988  		return out, metadata, err
1989  	}
1990  	return next.HandleInitialize(ctx, in)
1991  }
1992  
1993  type validateOpReleaseStaticIp struct {
1994  }
1995  
1996  func (*validateOpReleaseStaticIp) ID() string {
1997  	return "OperationInputValidation"
1998  }
1999  
2000  func (m *validateOpReleaseStaticIp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2001  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2002  ) {
2003  	input, ok := in.Parameters.(*ReleaseStaticIpInput)
2004  	if !ok {
2005  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2006  	}
2007  	if err := validateOpReleaseStaticIpInput(input); err != nil {
2008  		return out, metadata, err
2009  	}
2010  	return next.HandleInitialize(ctx, in)
2011  }
2012  
2013  type validateOpSendContactMethodVerification struct {
2014  }
2015  
2016  func (*validateOpSendContactMethodVerification) ID() string {
2017  	return "OperationInputValidation"
2018  }
2019  
2020  func (m *validateOpSendContactMethodVerification) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2021  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2022  ) {
2023  	input, ok := in.Parameters.(*SendContactMethodVerificationInput)
2024  	if !ok {
2025  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2026  	}
2027  	if err := validateOpSendContactMethodVerificationInput(input); err != nil {
2028  		return out, metadata, err
2029  	}
2030  	return next.HandleInitialize(ctx, in)
2031  }
2032  
2033  type validateOpSetIpAddressType struct {
2034  }
2035  
2036  func (*validateOpSetIpAddressType) ID() string {
2037  	return "OperationInputValidation"
2038  }
2039  
2040  func (m *validateOpSetIpAddressType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2041  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2042  ) {
2043  	input, ok := in.Parameters.(*SetIpAddressTypeInput)
2044  	if !ok {
2045  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2046  	}
2047  	if err := validateOpSetIpAddressTypeInput(input); err != nil {
2048  		return out, metadata, err
2049  	}
2050  	return next.HandleInitialize(ctx, in)
2051  }
2052  
2053  type validateOpSetResourceAccessForBucket struct {
2054  }
2055  
2056  func (*validateOpSetResourceAccessForBucket) ID() string {
2057  	return "OperationInputValidation"
2058  }
2059  
2060  func (m *validateOpSetResourceAccessForBucket) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2061  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2062  ) {
2063  	input, ok := in.Parameters.(*SetResourceAccessForBucketInput)
2064  	if !ok {
2065  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2066  	}
2067  	if err := validateOpSetResourceAccessForBucketInput(input); err != nil {
2068  		return out, metadata, err
2069  	}
2070  	return next.HandleInitialize(ctx, in)
2071  }
2072  
2073  type validateOpSetupInstanceHttps struct {
2074  }
2075  
2076  func (*validateOpSetupInstanceHttps) ID() string {
2077  	return "OperationInputValidation"
2078  }
2079  
2080  func (m *validateOpSetupInstanceHttps) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2081  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2082  ) {
2083  	input, ok := in.Parameters.(*SetupInstanceHttpsInput)
2084  	if !ok {
2085  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2086  	}
2087  	if err := validateOpSetupInstanceHttpsInput(input); err != nil {
2088  		return out, metadata, err
2089  	}
2090  	return next.HandleInitialize(ctx, in)
2091  }
2092  
2093  type validateOpStartGUISession struct {
2094  }
2095  
2096  func (*validateOpStartGUISession) ID() string {
2097  	return "OperationInputValidation"
2098  }
2099  
2100  func (m *validateOpStartGUISession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2101  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2102  ) {
2103  	input, ok := in.Parameters.(*StartGUISessionInput)
2104  	if !ok {
2105  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2106  	}
2107  	if err := validateOpStartGUISessionInput(input); err != nil {
2108  		return out, metadata, err
2109  	}
2110  	return next.HandleInitialize(ctx, in)
2111  }
2112  
2113  type validateOpStartInstance struct {
2114  }
2115  
2116  func (*validateOpStartInstance) ID() string {
2117  	return "OperationInputValidation"
2118  }
2119  
2120  func (m *validateOpStartInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2121  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2122  ) {
2123  	input, ok := in.Parameters.(*StartInstanceInput)
2124  	if !ok {
2125  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2126  	}
2127  	if err := validateOpStartInstanceInput(input); err != nil {
2128  		return out, metadata, err
2129  	}
2130  	return next.HandleInitialize(ctx, in)
2131  }
2132  
2133  type validateOpStartRelationalDatabase struct {
2134  }
2135  
2136  func (*validateOpStartRelationalDatabase) ID() string {
2137  	return "OperationInputValidation"
2138  }
2139  
2140  func (m *validateOpStartRelationalDatabase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2141  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2142  ) {
2143  	input, ok := in.Parameters.(*StartRelationalDatabaseInput)
2144  	if !ok {
2145  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2146  	}
2147  	if err := validateOpStartRelationalDatabaseInput(input); err != nil {
2148  		return out, metadata, err
2149  	}
2150  	return next.HandleInitialize(ctx, in)
2151  }
2152  
2153  type validateOpStopGUISession struct {
2154  }
2155  
2156  func (*validateOpStopGUISession) ID() string {
2157  	return "OperationInputValidation"
2158  }
2159  
2160  func (m *validateOpStopGUISession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2161  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2162  ) {
2163  	input, ok := in.Parameters.(*StopGUISessionInput)
2164  	if !ok {
2165  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2166  	}
2167  	if err := validateOpStopGUISessionInput(input); err != nil {
2168  		return out, metadata, err
2169  	}
2170  	return next.HandleInitialize(ctx, in)
2171  }
2172  
2173  type validateOpStopInstance struct {
2174  }
2175  
2176  func (*validateOpStopInstance) ID() string {
2177  	return "OperationInputValidation"
2178  }
2179  
2180  func (m *validateOpStopInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2181  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2182  ) {
2183  	input, ok := in.Parameters.(*StopInstanceInput)
2184  	if !ok {
2185  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2186  	}
2187  	if err := validateOpStopInstanceInput(input); err != nil {
2188  		return out, metadata, err
2189  	}
2190  	return next.HandleInitialize(ctx, in)
2191  }
2192  
2193  type validateOpStopRelationalDatabase struct {
2194  }
2195  
2196  func (*validateOpStopRelationalDatabase) ID() string {
2197  	return "OperationInputValidation"
2198  }
2199  
2200  func (m *validateOpStopRelationalDatabase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2201  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2202  ) {
2203  	input, ok := in.Parameters.(*StopRelationalDatabaseInput)
2204  	if !ok {
2205  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2206  	}
2207  	if err := validateOpStopRelationalDatabaseInput(input); err != nil {
2208  		return out, metadata, err
2209  	}
2210  	return next.HandleInitialize(ctx, in)
2211  }
2212  
2213  type validateOpTagResource struct {
2214  }
2215  
2216  func (*validateOpTagResource) ID() string {
2217  	return "OperationInputValidation"
2218  }
2219  
2220  func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2221  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2222  ) {
2223  	input, ok := in.Parameters.(*TagResourceInput)
2224  	if !ok {
2225  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2226  	}
2227  	if err := validateOpTagResourceInput(input); err != nil {
2228  		return out, metadata, err
2229  	}
2230  	return next.HandleInitialize(ctx, in)
2231  }
2232  
2233  type validateOpTestAlarm struct {
2234  }
2235  
2236  func (*validateOpTestAlarm) ID() string {
2237  	return "OperationInputValidation"
2238  }
2239  
2240  func (m *validateOpTestAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2241  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2242  ) {
2243  	input, ok := in.Parameters.(*TestAlarmInput)
2244  	if !ok {
2245  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2246  	}
2247  	if err := validateOpTestAlarmInput(input); err != nil {
2248  		return out, metadata, err
2249  	}
2250  	return next.HandleInitialize(ctx, in)
2251  }
2252  
2253  type validateOpUntagResource struct {
2254  }
2255  
2256  func (*validateOpUntagResource) ID() string {
2257  	return "OperationInputValidation"
2258  }
2259  
2260  func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2261  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2262  ) {
2263  	input, ok := in.Parameters.(*UntagResourceInput)
2264  	if !ok {
2265  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2266  	}
2267  	if err := validateOpUntagResourceInput(input); err != nil {
2268  		return out, metadata, err
2269  	}
2270  	return next.HandleInitialize(ctx, in)
2271  }
2272  
2273  type validateOpUpdateBucketBundle struct {
2274  }
2275  
2276  func (*validateOpUpdateBucketBundle) ID() string {
2277  	return "OperationInputValidation"
2278  }
2279  
2280  func (m *validateOpUpdateBucketBundle) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2281  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2282  ) {
2283  	input, ok := in.Parameters.(*UpdateBucketBundleInput)
2284  	if !ok {
2285  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2286  	}
2287  	if err := validateOpUpdateBucketBundleInput(input); err != nil {
2288  		return out, metadata, err
2289  	}
2290  	return next.HandleInitialize(ctx, in)
2291  }
2292  
2293  type validateOpUpdateBucket struct {
2294  }
2295  
2296  func (*validateOpUpdateBucket) ID() string {
2297  	return "OperationInputValidation"
2298  }
2299  
2300  func (m *validateOpUpdateBucket) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2301  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2302  ) {
2303  	input, ok := in.Parameters.(*UpdateBucketInput)
2304  	if !ok {
2305  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2306  	}
2307  	if err := validateOpUpdateBucketInput(input); err != nil {
2308  		return out, metadata, err
2309  	}
2310  	return next.HandleInitialize(ctx, in)
2311  }
2312  
2313  type validateOpUpdateContainerService struct {
2314  }
2315  
2316  func (*validateOpUpdateContainerService) ID() string {
2317  	return "OperationInputValidation"
2318  }
2319  
2320  func (m *validateOpUpdateContainerService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2321  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2322  ) {
2323  	input, ok := in.Parameters.(*UpdateContainerServiceInput)
2324  	if !ok {
2325  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2326  	}
2327  	if err := validateOpUpdateContainerServiceInput(input); err != nil {
2328  		return out, metadata, err
2329  	}
2330  	return next.HandleInitialize(ctx, in)
2331  }
2332  
2333  type validateOpUpdateDistribution struct {
2334  }
2335  
2336  func (*validateOpUpdateDistribution) ID() string {
2337  	return "OperationInputValidation"
2338  }
2339  
2340  func (m *validateOpUpdateDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2341  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2342  ) {
2343  	input, ok := in.Parameters.(*UpdateDistributionInput)
2344  	if !ok {
2345  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2346  	}
2347  	if err := validateOpUpdateDistributionInput(input); err != nil {
2348  		return out, metadata, err
2349  	}
2350  	return next.HandleInitialize(ctx, in)
2351  }
2352  
2353  type validateOpUpdateDomainEntry struct {
2354  }
2355  
2356  func (*validateOpUpdateDomainEntry) ID() string {
2357  	return "OperationInputValidation"
2358  }
2359  
2360  func (m *validateOpUpdateDomainEntry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2361  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2362  ) {
2363  	input, ok := in.Parameters.(*UpdateDomainEntryInput)
2364  	if !ok {
2365  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2366  	}
2367  	if err := validateOpUpdateDomainEntryInput(input); err != nil {
2368  		return out, metadata, err
2369  	}
2370  	return next.HandleInitialize(ctx, in)
2371  }
2372  
2373  type validateOpUpdateInstanceMetadataOptions struct {
2374  }
2375  
2376  func (*validateOpUpdateInstanceMetadataOptions) ID() string {
2377  	return "OperationInputValidation"
2378  }
2379  
2380  func (m *validateOpUpdateInstanceMetadataOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2381  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2382  ) {
2383  	input, ok := in.Parameters.(*UpdateInstanceMetadataOptionsInput)
2384  	if !ok {
2385  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2386  	}
2387  	if err := validateOpUpdateInstanceMetadataOptionsInput(input); err != nil {
2388  		return out, metadata, err
2389  	}
2390  	return next.HandleInitialize(ctx, in)
2391  }
2392  
2393  type validateOpUpdateLoadBalancerAttribute struct {
2394  }
2395  
2396  func (*validateOpUpdateLoadBalancerAttribute) ID() string {
2397  	return "OperationInputValidation"
2398  }
2399  
2400  func (m *validateOpUpdateLoadBalancerAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2401  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2402  ) {
2403  	input, ok := in.Parameters.(*UpdateLoadBalancerAttributeInput)
2404  	if !ok {
2405  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2406  	}
2407  	if err := validateOpUpdateLoadBalancerAttributeInput(input); err != nil {
2408  		return out, metadata, err
2409  	}
2410  	return next.HandleInitialize(ctx, in)
2411  }
2412  
2413  type validateOpUpdateRelationalDatabase struct {
2414  }
2415  
2416  func (*validateOpUpdateRelationalDatabase) ID() string {
2417  	return "OperationInputValidation"
2418  }
2419  
2420  func (m *validateOpUpdateRelationalDatabase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2421  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2422  ) {
2423  	input, ok := in.Parameters.(*UpdateRelationalDatabaseInput)
2424  	if !ok {
2425  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2426  	}
2427  	if err := validateOpUpdateRelationalDatabaseInput(input); err != nil {
2428  		return out, metadata, err
2429  	}
2430  	return next.HandleInitialize(ctx, in)
2431  }
2432  
2433  type validateOpUpdateRelationalDatabaseParameters struct {
2434  }
2435  
2436  func (*validateOpUpdateRelationalDatabaseParameters) ID() string {
2437  	return "OperationInputValidation"
2438  }
2439  
2440  func (m *validateOpUpdateRelationalDatabaseParameters) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2441  	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2442  ) {
2443  	input, ok := in.Parameters.(*UpdateRelationalDatabaseParametersInput)
2444  	if !ok {
2445  		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2446  	}
2447  	if err := validateOpUpdateRelationalDatabaseParametersInput(input); err != nil {
2448  		return out, metadata, err
2449  	}
2450  	return next.HandleInitialize(ctx, in)
2451  }
2452  
2453  func addOpAllocateStaticIpValidationMiddleware(stack *middleware.Stack) error {
2454  	return stack.Initialize.Add(&validateOpAllocateStaticIp{}, middleware.After)
2455  }
2456  
2457  func addOpAttachCertificateToDistributionValidationMiddleware(stack *middleware.Stack) error {
2458  	return stack.Initialize.Add(&validateOpAttachCertificateToDistribution{}, middleware.After)
2459  }
2460  
2461  func addOpAttachDiskValidationMiddleware(stack *middleware.Stack) error {
2462  	return stack.Initialize.Add(&validateOpAttachDisk{}, middleware.After)
2463  }
2464  
2465  func addOpAttachInstancesToLoadBalancerValidationMiddleware(stack *middleware.Stack) error {
2466  	return stack.Initialize.Add(&validateOpAttachInstancesToLoadBalancer{}, middleware.After)
2467  }
2468  
2469  func addOpAttachLoadBalancerTlsCertificateValidationMiddleware(stack *middleware.Stack) error {
2470  	return stack.Initialize.Add(&validateOpAttachLoadBalancerTlsCertificate{}, middleware.After)
2471  }
2472  
2473  func addOpAttachStaticIpValidationMiddleware(stack *middleware.Stack) error {
2474  	return stack.Initialize.Add(&validateOpAttachStaticIp{}, middleware.After)
2475  }
2476  
2477  func addOpCloseInstancePublicPortsValidationMiddleware(stack *middleware.Stack) error {
2478  	return stack.Initialize.Add(&validateOpCloseInstancePublicPorts{}, middleware.After)
2479  }
2480  
2481  func addOpCopySnapshotValidationMiddleware(stack *middleware.Stack) error {
2482  	return stack.Initialize.Add(&validateOpCopySnapshot{}, middleware.After)
2483  }
2484  
2485  func addOpCreateBucketAccessKeyValidationMiddleware(stack *middleware.Stack) error {
2486  	return stack.Initialize.Add(&validateOpCreateBucketAccessKey{}, middleware.After)
2487  }
2488  
2489  func addOpCreateBucketValidationMiddleware(stack *middleware.Stack) error {
2490  	return stack.Initialize.Add(&validateOpCreateBucket{}, middleware.After)
2491  }
2492  
2493  func addOpCreateCertificateValidationMiddleware(stack *middleware.Stack) error {
2494  	return stack.Initialize.Add(&validateOpCreateCertificate{}, middleware.After)
2495  }
2496  
2497  func addOpCreateCloudFormationStackValidationMiddleware(stack *middleware.Stack) error {
2498  	return stack.Initialize.Add(&validateOpCreateCloudFormationStack{}, middleware.After)
2499  }
2500  
2501  func addOpCreateContactMethodValidationMiddleware(stack *middleware.Stack) error {
2502  	return stack.Initialize.Add(&validateOpCreateContactMethod{}, middleware.After)
2503  }
2504  
2505  func addOpCreateContainerServiceDeploymentValidationMiddleware(stack *middleware.Stack) error {
2506  	return stack.Initialize.Add(&validateOpCreateContainerServiceDeployment{}, middleware.After)
2507  }
2508  
2509  func addOpCreateContainerServiceValidationMiddleware(stack *middleware.Stack) error {
2510  	return stack.Initialize.Add(&validateOpCreateContainerService{}, middleware.After)
2511  }
2512  
2513  func addOpCreateDiskFromSnapshotValidationMiddleware(stack *middleware.Stack) error {
2514  	return stack.Initialize.Add(&validateOpCreateDiskFromSnapshot{}, middleware.After)
2515  }
2516  
2517  func addOpCreateDiskValidationMiddleware(stack *middleware.Stack) error {
2518  	return stack.Initialize.Add(&validateOpCreateDisk{}, middleware.After)
2519  }
2520  
2521  func addOpCreateDiskSnapshotValidationMiddleware(stack *middleware.Stack) error {
2522  	return stack.Initialize.Add(&validateOpCreateDiskSnapshot{}, middleware.After)
2523  }
2524  
2525  func addOpCreateDistributionValidationMiddleware(stack *middleware.Stack) error {
2526  	return stack.Initialize.Add(&validateOpCreateDistribution{}, middleware.After)
2527  }
2528  
2529  func addOpCreateDomainEntryValidationMiddleware(stack *middleware.Stack) error {
2530  	return stack.Initialize.Add(&validateOpCreateDomainEntry{}, middleware.After)
2531  }
2532  
2533  func addOpCreateDomainValidationMiddleware(stack *middleware.Stack) error {
2534  	return stack.Initialize.Add(&validateOpCreateDomain{}, middleware.After)
2535  }
2536  
2537  func addOpCreateGUISessionAccessDetailsValidationMiddleware(stack *middleware.Stack) error {
2538  	return stack.Initialize.Add(&validateOpCreateGUISessionAccessDetails{}, middleware.After)
2539  }
2540  
2541  func addOpCreateInstancesFromSnapshotValidationMiddleware(stack *middleware.Stack) error {
2542  	return stack.Initialize.Add(&validateOpCreateInstancesFromSnapshot{}, middleware.After)
2543  }
2544  
2545  func addOpCreateInstancesValidationMiddleware(stack *middleware.Stack) error {
2546  	return stack.Initialize.Add(&validateOpCreateInstances{}, middleware.After)
2547  }
2548  
2549  func addOpCreateInstanceSnapshotValidationMiddleware(stack *middleware.Stack) error {
2550  	return stack.Initialize.Add(&validateOpCreateInstanceSnapshot{}, middleware.After)
2551  }
2552  
2553  func addOpCreateKeyPairValidationMiddleware(stack *middleware.Stack) error {
2554  	return stack.Initialize.Add(&validateOpCreateKeyPair{}, middleware.After)
2555  }
2556  
2557  func addOpCreateLoadBalancerValidationMiddleware(stack *middleware.Stack) error {
2558  	return stack.Initialize.Add(&validateOpCreateLoadBalancer{}, middleware.After)
2559  }
2560  
2561  func addOpCreateLoadBalancerTlsCertificateValidationMiddleware(stack *middleware.Stack) error {
2562  	return stack.Initialize.Add(&validateOpCreateLoadBalancerTlsCertificate{}, middleware.After)
2563  }
2564  
2565  func addOpCreateRelationalDatabaseFromSnapshotValidationMiddleware(stack *middleware.Stack) error {
2566  	return stack.Initialize.Add(&validateOpCreateRelationalDatabaseFromSnapshot{}, middleware.After)
2567  }
2568  
2569  func addOpCreateRelationalDatabaseValidationMiddleware(stack *middleware.Stack) error {
2570  	return stack.Initialize.Add(&validateOpCreateRelationalDatabase{}, middleware.After)
2571  }
2572  
2573  func addOpCreateRelationalDatabaseSnapshotValidationMiddleware(stack *middleware.Stack) error {
2574  	return stack.Initialize.Add(&validateOpCreateRelationalDatabaseSnapshot{}, middleware.After)
2575  }
2576  
2577  func addOpDeleteAlarmValidationMiddleware(stack *middleware.Stack) error {
2578  	return stack.Initialize.Add(&validateOpDeleteAlarm{}, middleware.After)
2579  }
2580  
2581  func addOpDeleteAutoSnapshotValidationMiddleware(stack *middleware.Stack) error {
2582  	return stack.Initialize.Add(&validateOpDeleteAutoSnapshot{}, middleware.After)
2583  }
2584  
2585  func addOpDeleteBucketAccessKeyValidationMiddleware(stack *middleware.Stack) error {
2586  	return stack.Initialize.Add(&validateOpDeleteBucketAccessKey{}, middleware.After)
2587  }
2588  
2589  func addOpDeleteBucketValidationMiddleware(stack *middleware.Stack) error {
2590  	return stack.Initialize.Add(&validateOpDeleteBucket{}, middleware.After)
2591  }
2592  
2593  func addOpDeleteCertificateValidationMiddleware(stack *middleware.Stack) error {
2594  	return stack.Initialize.Add(&validateOpDeleteCertificate{}, middleware.After)
2595  }
2596  
2597  func addOpDeleteContactMethodValidationMiddleware(stack *middleware.Stack) error {
2598  	return stack.Initialize.Add(&validateOpDeleteContactMethod{}, middleware.After)
2599  }
2600  
2601  func addOpDeleteContainerImageValidationMiddleware(stack *middleware.Stack) error {
2602  	return stack.Initialize.Add(&validateOpDeleteContainerImage{}, middleware.After)
2603  }
2604  
2605  func addOpDeleteContainerServiceValidationMiddleware(stack *middleware.Stack) error {
2606  	return stack.Initialize.Add(&validateOpDeleteContainerService{}, middleware.After)
2607  }
2608  
2609  func addOpDeleteDiskValidationMiddleware(stack *middleware.Stack) error {
2610  	return stack.Initialize.Add(&validateOpDeleteDisk{}, middleware.After)
2611  }
2612  
2613  func addOpDeleteDiskSnapshotValidationMiddleware(stack *middleware.Stack) error {
2614  	return stack.Initialize.Add(&validateOpDeleteDiskSnapshot{}, middleware.After)
2615  }
2616  
2617  func addOpDeleteDomainEntryValidationMiddleware(stack *middleware.Stack) error {
2618  	return stack.Initialize.Add(&validateOpDeleteDomainEntry{}, middleware.After)
2619  }
2620  
2621  func addOpDeleteDomainValidationMiddleware(stack *middleware.Stack) error {
2622  	return stack.Initialize.Add(&validateOpDeleteDomain{}, middleware.After)
2623  }
2624  
2625  func addOpDeleteInstanceValidationMiddleware(stack *middleware.Stack) error {
2626  	return stack.Initialize.Add(&validateOpDeleteInstance{}, middleware.After)
2627  }
2628  
2629  func addOpDeleteInstanceSnapshotValidationMiddleware(stack *middleware.Stack) error {
2630  	return stack.Initialize.Add(&validateOpDeleteInstanceSnapshot{}, middleware.After)
2631  }
2632  
2633  func addOpDeleteKeyPairValidationMiddleware(stack *middleware.Stack) error {
2634  	return stack.Initialize.Add(&validateOpDeleteKeyPair{}, middleware.After)
2635  }
2636  
2637  func addOpDeleteKnownHostKeysValidationMiddleware(stack *middleware.Stack) error {
2638  	return stack.Initialize.Add(&validateOpDeleteKnownHostKeys{}, middleware.After)
2639  }
2640  
2641  func addOpDeleteLoadBalancerValidationMiddleware(stack *middleware.Stack) error {
2642  	return stack.Initialize.Add(&validateOpDeleteLoadBalancer{}, middleware.After)
2643  }
2644  
2645  func addOpDeleteLoadBalancerTlsCertificateValidationMiddleware(stack *middleware.Stack) error {
2646  	return stack.Initialize.Add(&validateOpDeleteLoadBalancerTlsCertificate{}, middleware.After)
2647  }
2648  
2649  func addOpDeleteRelationalDatabaseValidationMiddleware(stack *middleware.Stack) error {
2650  	return stack.Initialize.Add(&validateOpDeleteRelationalDatabase{}, middleware.After)
2651  }
2652  
2653  func addOpDeleteRelationalDatabaseSnapshotValidationMiddleware(stack *middleware.Stack) error {
2654  	return stack.Initialize.Add(&validateOpDeleteRelationalDatabaseSnapshot{}, middleware.After)
2655  }
2656  
2657  func addOpDetachCertificateFromDistributionValidationMiddleware(stack *middleware.Stack) error {
2658  	return stack.Initialize.Add(&validateOpDetachCertificateFromDistribution{}, middleware.After)
2659  }
2660  
2661  func addOpDetachDiskValidationMiddleware(stack *middleware.Stack) error {
2662  	return stack.Initialize.Add(&validateOpDetachDisk{}, middleware.After)
2663  }
2664  
2665  func addOpDetachInstancesFromLoadBalancerValidationMiddleware(stack *middleware.Stack) error {
2666  	return stack.Initialize.Add(&validateOpDetachInstancesFromLoadBalancer{}, middleware.After)
2667  }
2668  
2669  func addOpDetachStaticIpValidationMiddleware(stack *middleware.Stack) error {
2670  	return stack.Initialize.Add(&validateOpDetachStaticIp{}, middleware.After)
2671  }
2672  
2673  func addOpDisableAddOnValidationMiddleware(stack *middleware.Stack) error {
2674  	return stack.Initialize.Add(&validateOpDisableAddOn{}, middleware.After)
2675  }
2676  
2677  func addOpEnableAddOnValidationMiddleware(stack *middleware.Stack) error {
2678  	return stack.Initialize.Add(&validateOpEnableAddOn{}, middleware.After)
2679  }
2680  
2681  func addOpExportSnapshotValidationMiddleware(stack *middleware.Stack) error {
2682  	return stack.Initialize.Add(&validateOpExportSnapshot{}, middleware.After)
2683  }
2684  
2685  func addOpGetAutoSnapshotsValidationMiddleware(stack *middleware.Stack) error {
2686  	return stack.Initialize.Add(&validateOpGetAutoSnapshots{}, middleware.After)
2687  }
2688  
2689  func addOpGetBucketAccessKeysValidationMiddleware(stack *middleware.Stack) error {
2690  	return stack.Initialize.Add(&validateOpGetBucketAccessKeys{}, middleware.After)
2691  }
2692  
2693  func addOpGetBucketMetricDataValidationMiddleware(stack *middleware.Stack) error {
2694  	return stack.Initialize.Add(&validateOpGetBucketMetricData{}, middleware.After)
2695  }
2696  
2697  func addOpGetContainerImagesValidationMiddleware(stack *middleware.Stack) error {
2698  	return stack.Initialize.Add(&validateOpGetContainerImages{}, middleware.After)
2699  }
2700  
2701  func addOpGetContainerLogValidationMiddleware(stack *middleware.Stack) error {
2702  	return stack.Initialize.Add(&validateOpGetContainerLog{}, middleware.After)
2703  }
2704  
2705  func addOpGetContainerServiceDeploymentsValidationMiddleware(stack *middleware.Stack) error {
2706  	return stack.Initialize.Add(&validateOpGetContainerServiceDeployments{}, middleware.After)
2707  }
2708  
2709  func addOpGetContainerServiceMetricDataValidationMiddleware(stack *middleware.Stack) error {
2710  	return stack.Initialize.Add(&validateOpGetContainerServiceMetricData{}, middleware.After)
2711  }
2712  
2713  func addOpGetCostEstimateValidationMiddleware(stack *middleware.Stack) error {
2714  	return stack.Initialize.Add(&validateOpGetCostEstimate{}, middleware.After)
2715  }
2716  
2717  func addOpGetDiskValidationMiddleware(stack *middleware.Stack) error {
2718  	return stack.Initialize.Add(&validateOpGetDisk{}, middleware.After)
2719  }
2720  
2721  func addOpGetDiskSnapshotValidationMiddleware(stack *middleware.Stack) error {
2722  	return stack.Initialize.Add(&validateOpGetDiskSnapshot{}, middleware.After)
2723  }
2724  
2725  func addOpGetDistributionMetricDataValidationMiddleware(stack *middleware.Stack) error {
2726  	return stack.Initialize.Add(&validateOpGetDistributionMetricData{}, middleware.After)
2727  }
2728  
2729  func addOpGetDomainValidationMiddleware(stack *middleware.Stack) error {
2730  	return stack.Initialize.Add(&validateOpGetDomain{}, middleware.After)
2731  }
2732  
2733  func addOpGetInstanceAccessDetailsValidationMiddleware(stack *middleware.Stack) error {
2734  	return stack.Initialize.Add(&validateOpGetInstanceAccessDetails{}, middleware.After)
2735  }
2736  
2737  func addOpGetInstanceValidationMiddleware(stack *middleware.Stack) error {
2738  	return stack.Initialize.Add(&validateOpGetInstance{}, middleware.After)
2739  }
2740  
2741  func addOpGetInstanceMetricDataValidationMiddleware(stack *middleware.Stack) error {
2742  	return stack.Initialize.Add(&validateOpGetInstanceMetricData{}, middleware.After)
2743  }
2744  
2745  func addOpGetInstancePortStatesValidationMiddleware(stack *middleware.Stack) error {
2746  	return stack.Initialize.Add(&validateOpGetInstancePortStates{}, middleware.After)
2747  }
2748  
2749  func addOpGetInstanceSnapshotValidationMiddleware(stack *middleware.Stack) error {
2750  	return stack.Initialize.Add(&validateOpGetInstanceSnapshot{}, middleware.After)
2751  }
2752  
2753  func addOpGetInstanceStateValidationMiddleware(stack *middleware.Stack) error {
2754  	return stack.Initialize.Add(&validateOpGetInstanceState{}, middleware.After)
2755  }
2756  
2757  func addOpGetKeyPairValidationMiddleware(stack *middleware.Stack) error {
2758  	return stack.Initialize.Add(&validateOpGetKeyPair{}, middleware.After)
2759  }
2760  
2761  func addOpGetLoadBalancerValidationMiddleware(stack *middleware.Stack) error {
2762  	return stack.Initialize.Add(&validateOpGetLoadBalancer{}, middleware.After)
2763  }
2764  
2765  func addOpGetLoadBalancerMetricDataValidationMiddleware(stack *middleware.Stack) error {
2766  	return stack.Initialize.Add(&validateOpGetLoadBalancerMetricData{}, middleware.After)
2767  }
2768  
2769  func addOpGetLoadBalancerTlsCertificatesValidationMiddleware(stack *middleware.Stack) error {
2770  	return stack.Initialize.Add(&validateOpGetLoadBalancerTlsCertificates{}, middleware.After)
2771  }
2772  
2773  func addOpGetOperationValidationMiddleware(stack *middleware.Stack) error {
2774  	return stack.Initialize.Add(&validateOpGetOperation{}, middleware.After)
2775  }
2776  
2777  func addOpGetOperationsForResourceValidationMiddleware(stack *middleware.Stack) error {
2778  	return stack.Initialize.Add(&validateOpGetOperationsForResource{}, middleware.After)
2779  }
2780  
2781  func addOpGetRelationalDatabaseEventsValidationMiddleware(stack *middleware.Stack) error {
2782  	return stack.Initialize.Add(&validateOpGetRelationalDatabaseEvents{}, middleware.After)
2783  }
2784  
2785  func addOpGetRelationalDatabaseValidationMiddleware(stack *middleware.Stack) error {
2786  	return stack.Initialize.Add(&validateOpGetRelationalDatabase{}, middleware.After)
2787  }
2788  
2789  func addOpGetRelationalDatabaseLogEventsValidationMiddleware(stack *middleware.Stack) error {
2790  	return stack.Initialize.Add(&validateOpGetRelationalDatabaseLogEvents{}, middleware.After)
2791  }
2792  
2793  func addOpGetRelationalDatabaseLogStreamsValidationMiddleware(stack *middleware.Stack) error {
2794  	return stack.Initialize.Add(&validateOpGetRelationalDatabaseLogStreams{}, middleware.After)
2795  }
2796  
2797  func addOpGetRelationalDatabaseMasterUserPasswordValidationMiddleware(stack *middleware.Stack) error {
2798  	return stack.Initialize.Add(&validateOpGetRelationalDatabaseMasterUserPassword{}, middleware.After)
2799  }
2800  
2801  func addOpGetRelationalDatabaseMetricDataValidationMiddleware(stack *middleware.Stack) error {
2802  	return stack.Initialize.Add(&validateOpGetRelationalDatabaseMetricData{}, middleware.After)
2803  }
2804  
2805  func addOpGetRelationalDatabaseParametersValidationMiddleware(stack *middleware.Stack) error {
2806  	return stack.Initialize.Add(&validateOpGetRelationalDatabaseParameters{}, middleware.After)
2807  }
2808  
2809  func addOpGetRelationalDatabaseSnapshotValidationMiddleware(stack *middleware.Stack) error {
2810  	return stack.Initialize.Add(&validateOpGetRelationalDatabaseSnapshot{}, middleware.After)
2811  }
2812  
2813  func addOpGetSetupHistoryValidationMiddleware(stack *middleware.Stack) error {
2814  	return stack.Initialize.Add(&validateOpGetSetupHistory{}, middleware.After)
2815  }
2816  
2817  func addOpGetStaticIpValidationMiddleware(stack *middleware.Stack) error {
2818  	return stack.Initialize.Add(&validateOpGetStaticIp{}, middleware.After)
2819  }
2820  
2821  func addOpImportKeyPairValidationMiddleware(stack *middleware.Stack) error {
2822  	return stack.Initialize.Add(&validateOpImportKeyPair{}, middleware.After)
2823  }
2824  
2825  func addOpOpenInstancePublicPortsValidationMiddleware(stack *middleware.Stack) error {
2826  	return stack.Initialize.Add(&validateOpOpenInstancePublicPorts{}, middleware.After)
2827  }
2828  
2829  func addOpPutAlarmValidationMiddleware(stack *middleware.Stack) error {
2830  	return stack.Initialize.Add(&validateOpPutAlarm{}, middleware.After)
2831  }
2832  
2833  func addOpPutInstancePublicPortsValidationMiddleware(stack *middleware.Stack) error {
2834  	return stack.Initialize.Add(&validateOpPutInstancePublicPorts{}, middleware.After)
2835  }
2836  
2837  func addOpRebootInstanceValidationMiddleware(stack *middleware.Stack) error {
2838  	return stack.Initialize.Add(&validateOpRebootInstance{}, middleware.After)
2839  }
2840  
2841  func addOpRebootRelationalDatabaseValidationMiddleware(stack *middleware.Stack) error {
2842  	return stack.Initialize.Add(&validateOpRebootRelationalDatabase{}, middleware.After)
2843  }
2844  
2845  func addOpRegisterContainerImageValidationMiddleware(stack *middleware.Stack) error {
2846  	return stack.Initialize.Add(&validateOpRegisterContainerImage{}, middleware.After)
2847  }
2848  
2849  func addOpReleaseStaticIpValidationMiddleware(stack *middleware.Stack) error {
2850  	return stack.Initialize.Add(&validateOpReleaseStaticIp{}, middleware.After)
2851  }
2852  
2853  func addOpSendContactMethodVerificationValidationMiddleware(stack *middleware.Stack) error {
2854  	return stack.Initialize.Add(&validateOpSendContactMethodVerification{}, middleware.After)
2855  }
2856  
2857  func addOpSetIpAddressTypeValidationMiddleware(stack *middleware.Stack) error {
2858  	return stack.Initialize.Add(&validateOpSetIpAddressType{}, middleware.After)
2859  }
2860  
2861  func addOpSetResourceAccessForBucketValidationMiddleware(stack *middleware.Stack) error {
2862  	return stack.Initialize.Add(&validateOpSetResourceAccessForBucket{}, middleware.After)
2863  }
2864  
2865  func addOpSetupInstanceHttpsValidationMiddleware(stack *middleware.Stack) error {
2866  	return stack.Initialize.Add(&validateOpSetupInstanceHttps{}, middleware.After)
2867  }
2868  
2869  func addOpStartGUISessionValidationMiddleware(stack *middleware.Stack) error {
2870  	return stack.Initialize.Add(&validateOpStartGUISession{}, middleware.After)
2871  }
2872  
2873  func addOpStartInstanceValidationMiddleware(stack *middleware.Stack) error {
2874  	return stack.Initialize.Add(&validateOpStartInstance{}, middleware.After)
2875  }
2876  
2877  func addOpStartRelationalDatabaseValidationMiddleware(stack *middleware.Stack) error {
2878  	return stack.Initialize.Add(&validateOpStartRelationalDatabase{}, middleware.After)
2879  }
2880  
2881  func addOpStopGUISessionValidationMiddleware(stack *middleware.Stack) error {
2882  	return stack.Initialize.Add(&validateOpStopGUISession{}, middleware.After)
2883  }
2884  
2885  func addOpStopInstanceValidationMiddleware(stack *middleware.Stack) error {
2886  	return stack.Initialize.Add(&validateOpStopInstance{}, middleware.After)
2887  }
2888  
2889  func addOpStopRelationalDatabaseValidationMiddleware(stack *middleware.Stack) error {
2890  	return stack.Initialize.Add(&validateOpStopRelationalDatabase{}, middleware.After)
2891  }
2892  
2893  func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
2894  	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
2895  }
2896  
2897  func addOpTestAlarmValidationMiddleware(stack *middleware.Stack) error {
2898  	return stack.Initialize.Add(&validateOpTestAlarm{}, middleware.After)
2899  }
2900  
2901  func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
2902  	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
2903  }
2904  
2905  func addOpUpdateBucketBundleValidationMiddleware(stack *middleware.Stack) error {
2906  	return stack.Initialize.Add(&validateOpUpdateBucketBundle{}, middleware.After)
2907  }
2908  
2909  func addOpUpdateBucketValidationMiddleware(stack *middleware.Stack) error {
2910  	return stack.Initialize.Add(&validateOpUpdateBucket{}, middleware.After)
2911  }
2912  
2913  func addOpUpdateContainerServiceValidationMiddleware(stack *middleware.Stack) error {
2914  	return stack.Initialize.Add(&validateOpUpdateContainerService{}, middleware.After)
2915  }
2916  
2917  func addOpUpdateDistributionValidationMiddleware(stack *middleware.Stack) error {
2918  	return stack.Initialize.Add(&validateOpUpdateDistribution{}, middleware.After)
2919  }
2920  
2921  func addOpUpdateDomainEntryValidationMiddleware(stack *middleware.Stack) error {
2922  	return stack.Initialize.Add(&validateOpUpdateDomainEntry{}, middleware.After)
2923  }
2924  
2925  func addOpUpdateInstanceMetadataOptionsValidationMiddleware(stack *middleware.Stack) error {
2926  	return stack.Initialize.Add(&validateOpUpdateInstanceMetadataOptions{}, middleware.After)
2927  }
2928  
2929  func addOpUpdateLoadBalancerAttributeValidationMiddleware(stack *middleware.Stack) error {
2930  	return stack.Initialize.Add(&validateOpUpdateLoadBalancerAttribute{}, middleware.After)
2931  }
2932  
2933  func addOpUpdateRelationalDatabaseValidationMiddleware(stack *middleware.Stack) error {
2934  	return stack.Initialize.Add(&validateOpUpdateRelationalDatabase{}, middleware.After)
2935  }
2936  
2937  func addOpUpdateRelationalDatabaseParametersValidationMiddleware(stack *middleware.Stack) error {
2938  	return stack.Initialize.Add(&validateOpUpdateRelationalDatabaseParameters{}, middleware.After)
2939  }
2940  
2941  func validateAddOnRequest(v *types.AddOnRequest) error {
2942  	if v == nil {
2943  		return nil
2944  	}
2945  	invalidParams := smithy.InvalidParamsError{Context: "AddOnRequest"}
2946  	if len(v.AddOnType) == 0 {
2947  		invalidParams.Add(smithy.NewErrParamRequired("AddOnType"))
2948  	}
2949  	if invalidParams.Len() > 0 {
2950  		return invalidParams
2951  	} else {
2952  		return nil
2953  	}
2954  }
2955  
2956  func validateAddOnRequestList(v []types.AddOnRequest) error {
2957  	if v == nil {
2958  		return nil
2959  	}
2960  	invalidParams := smithy.InvalidParamsError{Context: "AddOnRequestList"}
2961  	for i := range v {
2962  		if err := validateAddOnRequest(&v[i]); err != nil {
2963  			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2964  		}
2965  	}
2966  	if invalidParams.Len() > 0 {
2967  		return invalidParams
2968  	} else {
2969  		return nil
2970  	}
2971  }
2972  
2973  func validateBucketAccessLogConfig(v *types.BucketAccessLogConfig) error {
2974  	if v == nil {
2975  		return nil
2976  	}
2977  	invalidParams := smithy.InvalidParamsError{Context: "BucketAccessLogConfig"}
2978  	if v.Enabled == nil {
2979  		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
2980  	}
2981  	if invalidParams.Len() > 0 {
2982  		return invalidParams
2983  	} else {
2984  		return nil
2985  	}
2986  }
2987  
2988  func validateBucketCorsConfig(v *types.BucketCorsConfig) error {
2989  	if v == nil {
2990  		return nil
2991  	}
2992  	invalidParams := smithy.InvalidParamsError{Context: "BucketCorsConfig"}
2993  	if v.Rules != nil {
2994  		if err := validateBucketCorsRules(v.Rules); err != nil {
2995  			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
2996  		}
2997  	}
2998  	if invalidParams.Len() > 0 {
2999  		return invalidParams
3000  	} else {
3001  		return nil
3002  	}
3003  }
3004  
3005  func validateBucketCorsRule(v *types.BucketCorsRule) error {
3006  	if v == nil {
3007  		return nil
3008  	}
3009  	invalidParams := smithy.InvalidParamsError{Context: "BucketCorsRule"}
3010  	if v.AllowedMethods == nil {
3011  		invalidParams.Add(smithy.NewErrParamRequired("AllowedMethods"))
3012  	}
3013  	if v.AllowedOrigins == nil {
3014  		invalidParams.Add(smithy.NewErrParamRequired("AllowedOrigins"))
3015  	}
3016  	if invalidParams.Len() > 0 {
3017  		return invalidParams
3018  	} else {
3019  		return nil
3020  	}
3021  }
3022  
3023  func validateBucketCorsRules(v []types.BucketCorsRule) error {
3024  	if v == nil {
3025  		return nil
3026  	}
3027  	invalidParams := smithy.InvalidParamsError{Context: "BucketCorsRules"}
3028  	for i := range v {
3029  		if err := validateBucketCorsRule(&v[i]); err != nil {
3030  			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3031  		}
3032  	}
3033  	if invalidParams.Len() > 0 {
3034  		return invalidParams
3035  	} else {
3036  		return nil
3037  	}
3038  }
3039  
3040  func validateContainerServiceDeploymentRequest(v *types.ContainerServiceDeploymentRequest) error {
3041  	if v == nil {
3042  		return nil
3043  	}
3044  	invalidParams := smithy.InvalidParamsError{Context: "ContainerServiceDeploymentRequest"}
3045  	if v.PublicEndpoint != nil {
3046  		if err := validateEndpointRequest(v.PublicEndpoint); err != nil {
3047  			invalidParams.AddNested("PublicEndpoint", err.(smithy.InvalidParamsError))
3048  		}
3049  	}
3050  	if invalidParams.Len() > 0 {
3051  		return invalidParams
3052  	} else {
3053  		return nil
3054  	}
3055  }
3056  
3057  func validateEndpointRequest(v *types.EndpointRequest) error {
3058  	if v == nil {
3059  		return nil
3060  	}
3061  	invalidParams := smithy.InvalidParamsError{Context: "EndpointRequest"}
3062  	if v.ContainerName == nil {
3063  		invalidParams.Add(smithy.NewErrParamRequired("ContainerName"))
3064  	}
3065  	if v.ContainerPort == nil {
3066  		invalidParams.Add(smithy.NewErrParamRequired("ContainerPort"))
3067  	}
3068  	if invalidParams.Len() > 0 {
3069  		return invalidParams
3070  	} else {
3071  		return nil
3072  	}
3073  }
3074  
3075  func validateInstanceEntry(v *types.InstanceEntry) error {
3076  	if v == nil {
3077  		return nil
3078  	}
3079  	invalidParams := smithy.InvalidParamsError{Context: "InstanceEntry"}
3080  	if v.SourceName == nil {
3081  		invalidParams.Add(smithy.NewErrParamRequired("SourceName"))
3082  	}
3083  	if v.InstanceType == nil {
3084  		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
3085  	}
3086  	if len(v.PortInfoSource) == 0 {
3087  		invalidParams.Add(smithy.NewErrParamRequired("PortInfoSource"))
3088  	}
3089  	if v.AvailabilityZone == nil {
3090  		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
3091  	}
3092  	if invalidParams.Len() > 0 {
3093  		return invalidParams
3094  	} else {
3095  		return nil
3096  	}
3097  }
3098  
3099  func validateInstanceEntryList(v []types.InstanceEntry) error {
3100  	if v == nil {
3101  		return nil
3102  	}
3103  	invalidParams := smithy.InvalidParamsError{Context: "InstanceEntryList"}
3104  	for i := range v {
3105  		if err := validateInstanceEntry(&v[i]); err != nil {
3106  			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3107  		}
3108  	}
3109  	if invalidParams.Len() > 0 {
3110  		return invalidParams
3111  	} else {
3112  		return nil
3113  	}
3114  }
3115  
3116  func validateOpAllocateStaticIpInput(v *AllocateStaticIpInput) error {
3117  	if v == nil {
3118  		return nil
3119  	}
3120  	invalidParams := smithy.InvalidParamsError{Context: "AllocateStaticIpInput"}
3121  	if v.StaticIpName == nil {
3122  		invalidParams.Add(smithy.NewErrParamRequired("StaticIpName"))
3123  	}
3124  	if invalidParams.Len() > 0 {
3125  		return invalidParams
3126  	} else {
3127  		return nil
3128  	}
3129  }
3130  
3131  func validateOpAttachCertificateToDistributionInput(v *AttachCertificateToDistributionInput) error {
3132  	if v == nil {
3133  		return nil
3134  	}
3135  	invalidParams := smithy.InvalidParamsError{Context: "AttachCertificateToDistributionInput"}
3136  	if v.DistributionName == nil {
3137  		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
3138  	}
3139  	if v.CertificateName == nil {
3140  		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
3141  	}
3142  	if invalidParams.Len() > 0 {
3143  		return invalidParams
3144  	} else {
3145  		return nil
3146  	}
3147  }
3148  
3149  func validateOpAttachDiskInput(v *AttachDiskInput) error {
3150  	if v == nil {
3151  		return nil
3152  	}
3153  	invalidParams := smithy.InvalidParamsError{Context: "AttachDiskInput"}
3154  	if v.DiskName == nil {
3155  		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
3156  	}
3157  	if v.InstanceName == nil {
3158  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
3159  	}
3160  	if v.DiskPath == nil {
3161  		invalidParams.Add(smithy.NewErrParamRequired("DiskPath"))
3162  	}
3163  	if invalidParams.Len() > 0 {
3164  		return invalidParams
3165  	} else {
3166  		return nil
3167  	}
3168  }
3169  
3170  func validateOpAttachInstancesToLoadBalancerInput(v *AttachInstancesToLoadBalancerInput) error {
3171  	if v == nil {
3172  		return nil
3173  	}
3174  	invalidParams := smithy.InvalidParamsError{Context: "AttachInstancesToLoadBalancerInput"}
3175  	if v.LoadBalancerName == nil {
3176  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
3177  	}
3178  	if v.InstanceNames == nil {
3179  		invalidParams.Add(smithy.NewErrParamRequired("InstanceNames"))
3180  	}
3181  	if invalidParams.Len() > 0 {
3182  		return invalidParams
3183  	} else {
3184  		return nil
3185  	}
3186  }
3187  
3188  func validateOpAttachLoadBalancerTlsCertificateInput(v *AttachLoadBalancerTlsCertificateInput) error {
3189  	if v == nil {
3190  		return nil
3191  	}
3192  	invalidParams := smithy.InvalidParamsError{Context: "AttachLoadBalancerTlsCertificateInput"}
3193  	if v.LoadBalancerName == nil {
3194  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
3195  	}
3196  	if v.CertificateName == nil {
3197  		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
3198  	}
3199  	if invalidParams.Len() > 0 {
3200  		return invalidParams
3201  	} else {
3202  		return nil
3203  	}
3204  }
3205  
3206  func validateOpAttachStaticIpInput(v *AttachStaticIpInput) error {
3207  	if v == nil {
3208  		return nil
3209  	}
3210  	invalidParams := smithy.InvalidParamsError{Context: "AttachStaticIpInput"}
3211  	if v.StaticIpName == nil {
3212  		invalidParams.Add(smithy.NewErrParamRequired("StaticIpName"))
3213  	}
3214  	if v.InstanceName == nil {
3215  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
3216  	}
3217  	if invalidParams.Len() > 0 {
3218  		return invalidParams
3219  	} else {
3220  		return nil
3221  	}
3222  }
3223  
3224  func validateOpCloseInstancePublicPortsInput(v *CloseInstancePublicPortsInput) error {
3225  	if v == nil {
3226  		return nil
3227  	}
3228  	invalidParams := smithy.InvalidParamsError{Context: "CloseInstancePublicPortsInput"}
3229  	if v.PortInfo == nil {
3230  		invalidParams.Add(smithy.NewErrParamRequired("PortInfo"))
3231  	}
3232  	if v.InstanceName == nil {
3233  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
3234  	}
3235  	if invalidParams.Len() > 0 {
3236  		return invalidParams
3237  	} else {
3238  		return nil
3239  	}
3240  }
3241  
3242  func validateOpCopySnapshotInput(v *CopySnapshotInput) error {
3243  	if v == nil {
3244  		return nil
3245  	}
3246  	invalidParams := smithy.InvalidParamsError{Context: "CopySnapshotInput"}
3247  	if v.TargetSnapshotName == nil {
3248  		invalidParams.Add(smithy.NewErrParamRequired("TargetSnapshotName"))
3249  	}
3250  	if len(v.SourceRegion) == 0 {
3251  		invalidParams.Add(smithy.NewErrParamRequired("SourceRegion"))
3252  	}
3253  	if invalidParams.Len() > 0 {
3254  		return invalidParams
3255  	} else {
3256  		return nil
3257  	}
3258  }
3259  
3260  func validateOpCreateBucketAccessKeyInput(v *CreateBucketAccessKeyInput) error {
3261  	if v == nil {
3262  		return nil
3263  	}
3264  	invalidParams := smithy.InvalidParamsError{Context: "CreateBucketAccessKeyInput"}
3265  	if v.BucketName == nil {
3266  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
3267  	}
3268  	if invalidParams.Len() > 0 {
3269  		return invalidParams
3270  	} else {
3271  		return nil
3272  	}
3273  }
3274  
3275  func validateOpCreateBucketInput(v *CreateBucketInput) error {
3276  	if v == nil {
3277  		return nil
3278  	}
3279  	invalidParams := smithy.InvalidParamsError{Context: "CreateBucketInput"}
3280  	if v.BucketName == nil {
3281  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
3282  	}
3283  	if v.BundleId == nil {
3284  		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
3285  	}
3286  	if invalidParams.Len() > 0 {
3287  		return invalidParams
3288  	} else {
3289  		return nil
3290  	}
3291  }
3292  
3293  func validateOpCreateCertificateInput(v *CreateCertificateInput) error {
3294  	if v == nil {
3295  		return nil
3296  	}
3297  	invalidParams := smithy.InvalidParamsError{Context: "CreateCertificateInput"}
3298  	if v.CertificateName == nil {
3299  		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
3300  	}
3301  	if v.DomainName == nil {
3302  		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3303  	}
3304  	if invalidParams.Len() > 0 {
3305  		return invalidParams
3306  	} else {
3307  		return nil
3308  	}
3309  }
3310  
3311  func validateOpCreateCloudFormationStackInput(v *CreateCloudFormationStackInput) error {
3312  	if v == nil {
3313  		return nil
3314  	}
3315  	invalidParams := smithy.InvalidParamsError{Context: "CreateCloudFormationStackInput"}
3316  	if v.Instances == nil {
3317  		invalidParams.Add(smithy.NewErrParamRequired("Instances"))
3318  	} else if v.Instances != nil {
3319  		if err := validateInstanceEntryList(v.Instances); err != nil {
3320  			invalidParams.AddNested("Instances", err.(smithy.InvalidParamsError))
3321  		}
3322  	}
3323  	if invalidParams.Len() > 0 {
3324  		return invalidParams
3325  	} else {
3326  		return nil
3327  	}
3328  }
3329  
3330  func validateOpCreateContactMethodInput(v *CreateContactMethodInput) error {
3331  	if v == nil {
3332  		return nil
3333  	}
3334  	invalidParams := smithy.InvalidParamsError{Context: "CreateContactMethodInput"}
3335  	if len(v.Protocol) == 0 {
3336  		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
3337  	}
3338  	if v.ContactEndpoint == nil {
3339  		invalidParams.Add(smithy.NewErrParamRequired("ContactEndpoint"))
3340  	}
3341  	if invalidParams.Len() > 0 {
3342  		return invalidParams
3343  	} else {
3344  		return nil
3345  	}
3346  }
3347  
3348  func validateOpCreateContainerServiceDeploymentInput(v *CreateContainerServiceDeploymentInput) error {
3349  	if v == nil {
3350  		return nil
3351  	}
3352  	invalidParams := smithy.InvalidParamsError{Context: "CreateContainerServiceDeploymentInput"}
3353  	if v.ServiceName == nil {
3354  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
3355  	}
3356  	if v.PublicEndpoint != nil {
3357  		if err := validateEndpointRequest(v.PublicEndpoint); err != nil {
3358  			invalidParams.AddNested("PublicEndpoint", err.(smithy.InvalidParamsError))
3359  		}
3360  	}
3361  	if invalidParams.Len() > 0 {
3362  		return invalidParams
3363  	} else {
3364  		return nil
3365  	}
3366  }
3367  
3368  func validateOpCreateContainerServiceInput(v *CreateContainerServiceInput) error {
3369  	if v == nil {
3370  		return nil
3371  	}
3372  	invalidParams := smithy.InvalidParamsError{Context: "CreateContainerServiceInput"}
3373  	if v.ServiceName == nil {
3374  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
3375  	}
3376  	if len(v.Power) == 0 {
3377  		invalidParams.Add(smithy.NewErrParamRequired("Power"))
3378  	}
3379  	if v.Scale == nil {
3380  		invalidParams.Add(smithy.NewErrParamRequired("Scale"))
3381  	}
3382  	if v.Deployment != nil {
3383  		if err := validateContainerServiceDeploymentRequest(v.Deployment); err != nil {
3384  			invalidParams.AddNested("Deployment", err.(smithy.InvalidParamsError))
3385  		}
3386  	}
3387  	if invalidParams.Len() > 0 {
3388  		return invalidParams
3389  	} else {
3390  		return nil
3391  	}
3392  }
3393  
3394  func validateOpCreateDiskFromSnapshotInput(v *CreateDiskFromSnapshotInput) error {
3395  	if v == nil {
3396  		return nil
3397  	}
3398  	invalidParams := smithy.InvalidParamsError{Context: "CreateDiskFromSnapshotInput"}
3399  	if v.DiskName == nil {
3400  		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
3401  	}
3402  	if v.AvailabilityZone == nil {
3403  		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
3404  	}
3405  	if v.SizeInGb == nil {
3406  		invalidParams.Add(smithy.NewErrParamRequired("SizeInGb"))
3407  	}
3408  	if v.AddOns != nil {
3409  		if err := validateAddOnRequestList(v.AddOns); err != nil {
3410  			invalidParams.AddNested("AddOns", err.(smithy.InvalidParamsError))
3411  		}
3412  	}
3413  	if invalidParams.Len() > 0 {
3414  		return invalidParams
3415  	} else {
3416  		return nil
3417  	}
3418  }
3419  
3420  func validateOpCreateDiskInput(v *CreateDiskInput) error {
3421  	if v == nil {
3422  		return nil
3423  	}
3424  	invalidParams := smithy.InvalidParamsError{Context: "CreateDiskInput"}
3425  	if v.DiskName == nil {
3426  		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
3427  	}
3428  	if v.AvailabilityZone == nil {
3429  		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
3430  	}
3431  	if v.SizeInGb == nil {
3432  		invalidParams.Add(smithy.NewErrParamRequired("SizeInGb"))
3433  	}
3434  	if v.AddOns != nil {
3435  		if err := validateAddOnRequestList(v.AddOns); err != nil {
3436  			invalidParams.AddNested("AddOns", err.(smithy.InvalidParamsError))
3437  		}
3438  	}
3439  	if invalidParams.Len() > 0 {
3440  		return invalidParams
3441  	} else {
3442  		return nil
3443  	}
3444  }
3445  
3446  func validateOpCreateDiskSnapshotInput(v *CreateDiskSnapshotInput) error {
3447  	if v == nil {
3448  		return nil
3449  	}
3450  	invalidParams := smithy.InvalidParamsError{Context: "CreateDiskSnapshotInput"}
3451  	if v.DiskSnapshotName == nil {
3452  		invalidParams.Add(smithy.NewErrParamRequired("DiskSnapshotName"))
3453  	}
3454  	if invalidParams.Len() > 0 {
3455  		return invalidParams
3456  	} else {
3457  		return nil
3458  	}
3459  }
3460  
3461  func validateOpCreateDistributionInput(v *CreateDistributionInput) error {
3462  	if v == nil {
3463  		return nil
3464  	}
3465  	invalidParams := smithy.InvalidParamsError{Context: "CreateDistributionInput"}
3466  	if v.DistributionName == nil {
3467  		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
3468  	}
3469  	if v.Origin == nil {
3470  		invalidParams.Add(smithy.NewErrParamRequired("Origin"))
3471  	}
3472  	if v.DefaultCacheBehavior == nil {
3473  		invalidParams.Add(smithy.NewErrParamRequired("DefaultCacheBehavior"))
3474  	}
3475  	if v.BundleId == nil {
3476  		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
3477  	}
3478  	if invalidParams.Len() > 0 {
3479  		return invalidParams
3480  	} else {
3481  		return nil
3482  	}
3483  }
3484  
3485  func validateOpCreateDomainEntryInput(v *CreateDomainEntryInput) error {
3486  	if v == nil {
3487  		return nil
3488  	}
3489  	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainEntryInput"}
3490  	if v.DomainName == nil {
3491  		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3492  	}
3493  	if v.DomainEntry == nil {
3494  		invalidParams.Add(smithy.NewErrParamRequired("DomainEntry"))
3495  	}
3496  	if invalidParams.Len() > 0 {
3497  		return invalidParams
3498  	} else {
3499  		return nil
3500  	}
3501  }
3502  
3503  func validateOpCreateDomainInput(v *CreateDomainInput) error {
3504  	if v == nil {
3505  		return nil
3506  	}
3507  	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainInput"}
3508  	if v.DomainName == nil {
3509  		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3510  	}
3511  	if invalidParams.Len() > 0 {
3512  		return invalidParams
3513  	} else {
3514  		return nil
3515  	}
3516  }
3517  
3518  func validateOpCreateGUISessionAccessDetailsInput(v *CreateGUISessionAccessDetailsInput) error {
3519  	if v == nil {
3520  		return nil
3521  	}
3522  	invalidParams := smithy.InvalidParamsError{Context: "CreateGUISessionAccessDetailsInput"}
3523  	if v.ResourceName == nil {
3524  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
3525  	}
3526  	if invalidParams.Len() > 0 {
3527  		return invalidParams
3528  	} else {
3529  		return nil
3530  	}
3531  }
3532  
3533  func validateOpCreateInstancesFromSnapshotInput(v *CreateInstancesFromSnapshotInput) error {
3534  	if v == nil {
3535  		return nil
3536  	}
3537  	invalidParams := smithy.InvalidParamsError{Context: "CreateInstancesFromSnapshotInput"}
3538  	if v.InstanceNames == nil {
3539  		invalidParams.Add(smithy.NewErrParamRequired("InstanceNames"))
3540  	}
3541  	if v.AvailabilityZone == nil {
3542  		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
3543  	}
3544  	if v.BundleId == nil {
3545  		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
3546  	}
3547  	if v.AddOns != nil {
3548  		if err := validateAddOnRequestList(v.AddOns); err != nil {
3549  			invalidParams.AddNested("AddOns", err.(smithy.InvalidParamsError))
3550  		}
3551  	}
3552  	if invalidParams.Len() > 0 {
3553  		return invalidParams
3554  	} else {
3555  		return nil
3556  	}
3557  }
3558  
3559  func validateOpCreateInstancesInput(v *CreateInstancesInput) error {
3560  	if v == nil {
3561  		return nil
3562  	}
3563  	invalidParams := smithy.InvalidParamsError{Context: "CreateInstancesInput"}
3564  	if v.InstanceNames == nil {
3565  		invalidParams.Add(smithy.NewErrParamRequired("InstanceNames"))
3566  	}
3567  	if v.AvailabilityZone == nil {
3568  		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
3569  	}
3570  	if v.BlueprintId == nil {
3571  		invalidParams.Add(smithy.NewErrParamRequired("BlueprintId"))
3572  	}
3573  	if v.BundleId == nil {
3574  		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
3575  	}
3576  	if v.AddOns != nil {
3577  		if err := validateAddOnRequestList(v.AddOns); err != nil {
3578  			invalidParams.AddNested("AddOns", err.(smithy.InvalidParamsError))
3579  		}
3580  	}
3581  	if invalidParams.Len() > 0 {
3582  		return invalidParams
3583  	} else {
3584  		return nil
3585  	}
3586  }
3587  
3588  func validateOpCreateInstanceSnapshotInput(v *CreateInstanceSnapshotInput) error {
3589  	if v == nil {
3590  		return nil
3591  	}
3592  	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceSnapshotInput"}
3593  	if v.InstanceSnapshotName == nil {
3594  		invalidParams.Add(smithy.NewErrParamRequired("InstanceSnapshotName"))
3595  	}
3596  	if v.InstanceName == nil {
3597  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
3598  	}
3599  	if invalidParams.Len() > 0 {
3600  		return invalidParams
3601  	} else {
3602  		return nil
3603  	}
3604  }
3605  
3606  func validateOpCreateKeyPairInput(v *CreateKeyPairInput) error {
3607  	if v == nil {
3608  		return nil
3609  	}
3610  	invalidParams := smithy.InvalidParamsError{Context: "CreateKeyPairInput"}
3611  	if v.KeyPairName == nil {
3612  		invalidParams.Add(smithy.NewErrParamRequired("KeyPairName"))
3613  	}
3614  	if invalidParams.Len() > 0 {
3615  		return invalidParams
3616  	} else {
3617  		return nil
3618  	}
3619  }
3620  
3621  func validateOpCreateLoadBalancerInput(v *CreateLoadBalancerInput) error {
3622  	if v == nil {
3623  		return nil
3624  	}
3625  	invalidParams := smithy.InvalidParamsError{Context: "CreateLoadBalancerInput"}
3626  	if v.LoadBalancerName == nil {
3627  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
3628  	}
3629  	if invalidParams.Len() > 0 {
3630  		return invalidParams
3631  	} else {
3632  		return nil
3633  	}
3634  }
3635  
3636  func validateOpCreateLoadBalancerTlsCertificateInput(v *CreateLoadBalancerTlsCertificateInput) error {
3637  	if v == nil {
3638  		return nil
3639  	}
3640  	invalidParams := smithy.InvalidParamsError{Context: "CreateLoadBalancerTlsCertificateInput"}
3641  	if v.LoadBalancerName == nil {
3642  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
3643  	}
3644  	if v.CertificateName == nil {
3645  		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
3646  	}
3647  	if v.CertificateDomainName == nil {
3648  		invalidParams.Add(smithy.NewErrParamRequired("CertificateDomainName"))
3649  	}
3650  	if invalidParams.Len() > 0 {
3651  		return invalidParams
3652  	} else {
3653  		return nil
3654  	}
3655  }
3656  
3657  func validateOpCreateRelationalDatabaseFromSnapshotInput(v *CreateRelationalDatabaseFromSnapshotInput) error {
3658  	if v == nil {
3659  		return nil
3660  	}
3661  	invalidParams := smithy.InvalidParamsError{Context: "CreateRelationalDatabaseFromSnapshotInput"}
3662  	if v.RelationalDatabaseName == nil {
3663  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
3664  	}
3665  	if invalidParams.Len() > 0 {
3666  		return invalidParams
3667  	} else {
3668  		return nil
3669  	}
3670  }
3671  
3672  func validateOpCreateRelationalDatabaseInput(v *CreateRelationalDatabaseInput) error {
3673  	if v == nil {
3674  		return nil
3675  	}
3676  	invalidParams := smithy.InvalidParamsError{Context: "CreateRelationalDatabaseInput"}
3677  	if v.RelationalDatabaseName == nil {
3678  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
3679  	}
3680  	if v.RelationalDatabaseBlueprintId == nil {
3681  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseBlueprintId"))
3682  	}
3683  	if v.RelationalDatabaseBundleId == nil {
3684  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseBundleId"))
3685  	}
3686  	if v.MasterDatabaseName == nil {
3687  		invalidParams.Add(smithy.NewErrParamRequired("MasterDatabaseName"))
3688  	}
3689  	if v.MasterUsername == nil {
3690  		invalidParams.Add(smithy.NewErrParamRequired("MasterUsername"))
3691  	}
3692  	if invalidParams.Len() > 0 {
3693  		return invalidParams
3694  	} else {
3695  		return nil
3696  	}
3697  }
3698  
3699  func validateOpCreateRelationalDatabaseSnapshotInput(v *CreateRelationalDatabaseSnapshotInput) error {
3700  	if v == nil {
3701  		return nil
3702  	}
3703  	invalidParams := smithy.InvalidParamsError{Context: "CreateRelationalDatabaseSnapshotInput"}
3704  	if v.RelationalDatabaseName == nil {
3705  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
3706  	}
3707  	if v.RelationalDatabaseSnapshotName == nil {
3708  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseSnapshotName"))
3709  	}
3710  	if invalidParams.Len() > 0 {
3711  		return invalidParams
3712  	} else {
3713  		return nil
3714  	}
3715  }
3716  
3717  func validateOpDeleteAlarmInput(v *DeleteAlarmInput) error {
3718  	if v == nil {
3719  		return nil
3720  	}
3721  	invalidParams := smithy.InvalidParamsError{Context: "DeleteAlarmInput"}
3722  	if v.AlarmName == nil {
3723  		invalidParams.Add(smithy.NewErrParamRequired("AlarmName"))
3724  	}
3725  	if invalidParams.Len() > 0 {
3726  		return invalidParams
3727  	} else {
3728  		return nil
3729  	}
3730  }
3731  
3732  func validateOpDeleteAutoSnapshotInput(v *DeleteAutoSnapshotInput) error {
3733  	if v == nil {
3734  		return nil
3735  	}
3736  	invalidParams := smithy.InvalidParamsError{Context: "DeleteAutoSnapshotInput"}
3737  	if v.ResourceName == nil {
3738  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
3739  	}
3740  	if v.Date == nil {
3741  		invalidParams.Add(smithy.NewErrParamRequired("Date"))
3742  	}
3743  	if invalidParams.Len() > 0 {
3744  		return invalidParams
3745  	} else {
3746  		return nil
3747  	}
3748  }
3749  
3750  func validateOpDeleteBucketAccessKeyInput(v *DeleteBucketAccessKeyInput) error {
3751  	if v == nil {
3752  		return nil
3753  	}
3754  	invalidParams := smithy.InvalidParamsError{Context: "DeleteBucketAccessKeyInput"}
3755  	if v.BucketName == nil {
3756  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
3757  	}
3758  	if v.AccessKeyId == nil {
3759  		invalidParams.Add(smithy.NewErrParamRequired("AccessKeyId"))
3760  	}
3761  	if invalidParams.Len() > 0 {
3762  		return invalidParams
3763  	} else {
3764  		return nil
3765  	}
3766  }
3767  
3768  func validateOpDeleteBucketInput(v *DeleteBucketInput) error {
3769  	if v == nil {
3770  		return nil
3771  	}
3772  	invalidParams := smithy.InvalidParamsError{Context: "DeleteBucketInput"}
3773  	if v.BucketName == nil {
3774  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
3775  	}
3776  	if invalidParams.Len() > 0 {
3777  		return invalidParams
3778  	} else {
3779  		return nil
3780  	}
3781  }
3782  
3783  func validateOpDeleteCertificateInput(v *DeleteCertificateInput) error {
3784  	if v == nil {
3785  		return nil
3786  	}
3787  	invalidParams := smithy.InvalidParamsError{Context: "DeleteCertificateInput"}
3788  	if v.CertificateName == nil {
3789  		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
3790  	}
3791  	if invalidParams.Len() > 0 {
3792  		return invalidParams
3793  	} else {
3794  		return nil
3795  	}
3796  }
3797  
3798  func validateOpDeleteContactMethodInput(v *DeleteContactMethodInput) error {
3799  	if v == nil {
3800  		return nil
3801  	}
3802  	invalidParams := smithy.InvalidParamsError{Context: "DeleteContactMethodInput"}
3803  	if len(v.Protocol) == 0 {
3804  		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
3805  	}
3806  	if invalidParams.Len() > 0 {
3807  		return invalidParams
3808  	} else {
3809  		return nil
3810  	}
3811  }
3812  
3813  func validateOpDeleteContainerImageInput(v *DeleteContainerImageInput) error {
3814  	if v == nil {
3815  		return nil
3816  	}
3817  	invalidParams := smithy.InvalidParamsError{Context: "DeleteContainerImageInput"}
3818  	if v.ServiceName == nil {
3819  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
3820  	}
3821  	if v.Image == nil {
3822  		invalidParams.Add(smithy.NewErrParamRequired("Image"))
3823  	}
3824  	if invalidParams.Len() > 0 {
3825  		return invalidParams
3826  	} else {
3827  		return nil
3828  	}
3829  }
3830  
3831  func validateOpDeleteContainerServiceInput(v *DeleteContainerServiceInput) error {
3832  	if v == nil {
3833  		return nil
3834  	}
3835  	invalidParams := smithy.InvalidParamsError{Context: "DeleteContainerServiceInput"}
3836  	if v.ServiceName == nil {
3837  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
3838  	}
3839  	if invalidParams.Len() > 0 {
3840  		return invalidParams
3841  	} else {
3842  		return nil
3843  	}
3844  }
3845  
3846  func validateOpDeleteDiskInput(v *DeleteDiskInput) error {
3847  	if v == nil {
3848  		return nil
3849  	}
3850  	invalidParams := smithy.InvalidParamsError{Context: "DeleteDiskInput"}
3851  	if v.DiskName == nil {
3852  		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
3853  	}
3854  	if invalidParams.Len() > 0 {
3855  		return invalidParams
3856  	} else {
3857  		return nil
3858  	}
3859  }
3860  
3861  func validateOpDeleteDiskSnapshotInput(v *DeleteDiskSnapshotInput) error {
3862  	if v == nil {
3863  		return nil
3864  	}
3865  	invalidParams := smithy.InvalidParamsError{Context: "DeleteDiskSnapshotInput"}
3866  	if v.DiskSnapshotName == nil {
3867  		invalidParams.Add(smithy.NewErrParamRequired("DiskSnapshotName"))
3868  	}
3869  	if invalidParams.Len() > 0 {
3870  		return invalidParams
3871  	} else {
3872  		return nil
3873  	}
3874  }
3875  
3876  func validateOpDeleteDomainEntryInput(v *DeleteDomainEntryInput) error {
3877  	if v == nil {
3878  		return nil
3879  	}
3880  	invalidParams := smithy.InvalidParamsError{Context: "DeleteDomainEntryInput"}
3881  	if v.DomainName == nil {
3882  		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3883  	}
3884  	if v.DomainEntry == nil {
3885  		invalidParams.Add(smithy.NewErrParamRequired("DomainEntry"))
3886  	}
3887  	if invalidParams.Len() > 0 {
3888  		return invalidParams
3889  	} else {
3890  		return nil
3891  	}
3892  }
3893  
3894  func validateOpDeleteDomainInput(v *DeleteDomainInput) error {
3895  	if v == nil {
3896  		return nil
3897  	}
3898  	invalidParams := smithy.InvalidParamsError{Context: "DeleteDomainInput"}
3899  	if v.DomainName == nil {
3900  		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3901  	}
3902  	if invalidParams.Len() > 0 {
3903  		return invalidParams
3904  	} else {
3905  		return nil
3906  	}
3907  }
3908  
3909  func validateOpDeleteInstanceInput(v *DeleteInstanceInput) error {
3910  	if v == nil {
3911  		return nil
3912  	}
3913  	invalidParams := smithy.InvalidParamsError{Context: "DeleteInstanceInput"}
3914  	if v.InstanceName == nil {
3915  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
3916  	}
3917  	if invalidParams.Len() > 0 {
3918  		return invalidParams
3919  	} else {
3920  		return nil
3921  	}
3922  }
3923  
3924  func validateOpDeleteInstanceSnapshotInput(v *DeleteInstanceSnapshotInput) error {
3925  	if v == nil {
3926  		return nil
3927  	}
3928  	invalidParams := smithy.InvalidParamsError{Context: "DeleteInstanceSnapshotInput"}
3929  	if v.InstanceSnapshotName == nil {
3930  		invalidParams.Add(smithy.NewErrParamRequired("InstanceSnapshotName"))
3931  	}
3932  	if invalidParams.Len() > 0 {
3933  		return invalidParams
3934  	} else {
3935  		return nil
3936  	}
3937  }
3938  
3939  func validateOpDeleteKeyPairInput(v *DeleteKeyPairInput) error {
3940  	if v == nil {
3941  		return nil
3942  	}
3943  	invalidParams := smithy.InvalidParamsError{Context: "DeleteKeyPairInput"}
3944  	if v.KeyPairName == nil {
3945  		invalidParams.Add(smithy.NewErrParamRequired("KeyPairName"))
3946  	}
3947  	if invalidParams.Len() > 0 {
3948  		return invalidParams
3949  	} else {
3950  		return nil
3951  	}
3952  }
3953  
3954  func validateOpDeleteKnownHostKeysInput(v *DeleteKnownHostKeysInput) error {
3955  	if v == nil {
3956  		return nil
3957  	}
3958  	invalidParams := smithy.InvalidParamsError{Context: "DeleteKnownHostKeysInput"}
3959  	if v.InstanceName == nil {
3960  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
3961  	}
3962  	if invalidParams.Len() > 0 {
3963  		return invalidParams
3964  	} else {
3965  		return nil
3966  	}
3967  }
3968  
3969  func validateOpDeleteLoadBalancerInput(v *DeleteLoadBalancerInput) error {
3970  	if v == nil {
3971  		return nil
3972  	}
3973  	invalidParams := smithy.InvalidParamsError{Context: "DeleteLoadBalancerInput"}
3974  	if v.LoadBalancerName == nil {
3975  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
3976  	}
3977  	if invalidParams.Len() > 0 {
3978  		return invalidParams
3979  	} else {
3980  		return nil
3981  	}
3982  }
3983  
3984  func validateOpDeleteLoadBalancerTlsCertificateInput(v *DeleteLoadBalancerTlsCertificateInput) error {
3985  	if v == nil {
3986  		return nil
3987  	}
3988  	invalidParams := smithy.InvalidParamsError{Context: "DeleteLoadBalancerTlsCertificateInput"}
3989  	if v.LoadBalancerName == nil {
3990  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
3991  	}
3992  	if v.CertificateName == nil {
3993  		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
3994  	}
3995  	if invalidParams.Len() > 0 {
3996  		return invalidParams
3997  	} else {
3998  		return nil
3999  	}
4000  }
4001  
4002  func validateOpDeleteRelationalDatabaseInput(v *DeleteRelationalDatabaseInput) error {
4003  	if v == nil {
4004  		return nil
4005  	}
4006  	invalidParams := smithy.InvalidParamsError{Context: "DeleteRelationalDatabaseInput"}
4007  	if v.RelationalDatabaseName == nil {
4008  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4009  	}
4010  	if invalidParams.Len() > 0 {
4011  		return invalidParams
4012  	} else {
4013  		return nil
4014  	}
4015  }
4016  
4017  func validateOpDeleteRelationalDatabaseSnapshotInput(v *DeleteRelationalDatabaseSnapshotInput) error {
4018  	if v == nil {
4019  		return nil
4020  	}
4021  	invalidParams := smithy.InvalidParamsError{Context: "DeleteRelationalDatabaseSnapshotInput"}
4022  	if v.RelationalDatabaseSnapshotName == nil {
4023  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseSnapshotName"))
4024  	}
4025  	if invalidParams.Len() > 0 {
4026  		return invalidParams
4027  	} else {
4028  		return nil
4029  	}
4030  }
4031  
4032  func validateOpDetachCertificateFromDistributionInput(v *DetachCertificateFromDistributionInput) error {
4033  	if v == nil {
4034  		return nil
4035  	}
4036  	invalidParams := smithy.InvalidParamsError{Context: "DetachCertificateFromDistributionInput"}
4037  	if v.DistributionName == nil {
4038  		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
4039  	}
4040  	if invalidParams.Len() > 0 {
4041  		return invalidParams
4042  	} else {
4043  		return nil
4044  	}
4045  }
4046  
4047  func validateOpDetachDiskInput(v *DetachDiskInput) error {
4048  	if v == nil {
4049  		return nil
4050  	}
4051  	invalidParams := smithy.InvalidParamsError{Context: "DetachDiskInput"}
4052  	if v.DiskName == nil {
4053  		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
4054  	}
4055  	if invalidParams.Len() > 0 {
4056  		return invalidParams
4057  	} else {
4058  		return nil
4059  	}
4060  }
4061  
4062  func validateOpDetachInstancesFromLoadBalancerInput(v *DetachInstancesFromLoadBalancerInput) error {
4063  	if v == nil {
4064  		return nil
4065  	}
4066  	invalidParams := smithy.InvalidParamsError{Context: "DetachInstancesFromLoadBalancerInput"}
4067  	if v.LoadBalancerName == nil {
4068  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
4069  	}
4070  	if v.InstanceNames == nil {
4071  		invalidParams.Add(smithy.NewErrParamRequired("InstanceNames"))
4072  	}
4073  	if invalidParams.Len() > 0 {
4074  		return invalidParams
4075  	} else {
4076  		return nil
4077  	}
4078  }
4079  
4080  func validateOpDetachStaticIpInput(v *DetachStaticIpInput) error {
4081  	if v == nil {
4082  		return nil
4083  	}
4084  	invalidParams := smithy.InvalidParamsError{Context: "DetachStaticIpInput"}
4085  	if v.StaticIpName == nil {
4086  		invalidParams.Add(smithy.NewErrParamRequired("StaticIpName"))
4087  	}
4088  	if invalidParams.Len() > 0 {
4089  		return invalidParams
4090  	} else {
4091  		return nil
4092  	}
4093  }
4094  
4095  func validateOpDisableAddOnInput(v *DisableAddOnInput) error {
4096  	if v == nil {
4097  		return nil
4098  	}
4099  	invalidParams := smithy.InvalidParamsError{Context: "DisableAddOnInput"}
4100  	if len(v.AddOnType) == 0 {
4101  		invalidParams.Add(smithy.NewErrParamRequired("AddOnType"))
4102  	}
4103  	if v.ResourceName == nil {
4104  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
4105  	}
4106  	if invalidParams.Len() > 0 {
4107  		return invalidParams
4108  	} else {
4109  		return nil
4110  	}
4111  }
4112  
4113  func validateOpEnableAddOnInput(v *EnableAddOnInput) error {
4114  	if v == nil {
4115  		return nil
4116  	}
4117  	invalidParams := smithy.InvalidParamsError{Context: "EnableAddOnInput"}
4118  	if v.ResourceName == nil {
4119  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
4120  	}
4121  	if v.AddOnRequest == nil {
4122  		invalidParams.Add(smithy.NewErrParamRequired("AddOnRequest"))
4123  	} else if v.AddOnRequest != nil {
4124  		if err := validateAddOnRequest(v.AddOnRequest); err != nil {
4125  			invalidParams.AddNested("AddOnRequest", err.(smithy.InvalidParamsError))
4126  		}
4127  	}
4128  	if invalidParams.Len() > 0 {
4129  		return invalidParams
4130  	} else {
4131  		return nil
4132  	}
4133  }
4134  
4135  func validateOpExportSnapshotInput(v *ExportSnapshotInput) error {
4136  	if v == nil {
4137  		return nil
4138  	}
4139  	invalidParams := smithy.InvalidParamsError{Context: "ExportSnapshotInput"}
4140  	if v.SourceSnapshotName == nil {
4141  		invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotName"))
4142  	}
4143  	if invalidParams.Len() > 0 {
4144  		return invalidParams
4145  	} else {
4146  		return nil
4147  	}
4148  }
4149  
4150  func validateOpGetAutoSnapshotsInput(v *GetAutoSnapshotsInput) error {
4151  	if v == nil {
4152  		return nil
4153  	}
4154  	invalidParams := smithy.InvalidParamsError{Context: "GetAutoSnapshotsInput"}
4155  	if v.ResourceName == nil {
4156  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
4157  	}
4158  	if invalidParams.Len() > 0 {
4159  		return invalidParams
4160  	} else {
4161  		return nil
4162  	}
4163  }
4164  
4165  func validateOpGetBucketAccessKeysInput(v *GetBucketAccessKeysInput) error {
4166  	if v == nil {
4167  		return nil
4168  	}
4169  	invalidParams := smithy.InvalidParamsError{Context: "GetBucketAccessKeysInput"}
4170  	if v.BucketName == nil {
4171  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
4172  	}
4173  	if invalidParams.Len() > 0 {
4174  		return invalidParams
4175  	} else {
4176  		return nil
4177  	}
4178  }
4179  
4180  func validateOpGetBucketMetricDataInput(v *GetBucketMetricDataInput) error {
4181  	if v == nil {
4182  		return nil
4183  	}
4184  	invalidParams := smithy.InvalidParamsError{Context: "GetBucketMetricDataInput"}
4185  	if v.BucketName == nil {
4186  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
4187  	}
4188  	if len(v.MetricName) == 0 {
4189  		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
4190  	}
4191  	if v.StartTime == nil {
4192  		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
4193  	}
4194  	if v.EndTime == nil {
4195  		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
4196  	}
4197  	if v.Period == nil {
4198  		invalidParams.Add(smithy.NewErrParamRequired("Period"))
4199  	}
4200  	if v.Statistics == nil {
4201  		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
4202  	}
4203  	if len(v.Unit) == 0 {
4204  		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
4205  	}
4206  	if invalidParams.Len() > 0 {
4207  		return invalidParams
4208  	} else {
4209  		return nil
4210  	}
4211  }
4212  
4213  func validateOpGetContainerImagesInput(v *GetContainerImagesInput) error {
4214  	if v == nil {
4215  		return nil
4216  	}
4217  	invalidParams := smithy.InvalidParamsError{Context: "GetContainerImagesInput"}
4218  	if v.ServiceName == nil {
4219  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
4220  	}
4221  	if invalidParams.Len() > 0 {
4222  		return invalidParams
4223  	} else {
4224  		return nil
4225  	}
4226  }
4227  
4228  func validateOpGetContainerLogInput(v *GetContainerLogInput) error {
4229  	if v == nil {
4230  		return nil
4231  	}
4232  	invalidParams := smithy.InvalidParamsError{Context: "GetContainerLogInput"}
4233  	if v.ServiceName == nil {
4234  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
4235  	}
4236  	if v.ContainerName == nil {
4237  		invalidParams.Add(smithy.NewErrParamRequired("ContainerName"))
4238  	}
4239  	if invalidParams.Len() > 0 {
4240  		return invalidParams
4241  	} else {
4242  		return nil
4243  	}
4244  }
4245  
4246  func validateOpGetContainerServiceDeploymentsInput(v *GetContainerServiceDeploymentsInput) error {
4247  	if v == nil {
4248  		return nil
4249  	}
4250  	invalidParams := smithy.InvalidParamsError{Context: "GetContainerServiceDeploymentsInput"}
4251  	if v.ServiceName == nil {
4252  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
4253  	}
4254  	if invalidParams.Len() > 0 {
4255  		return invalidParams
4256  	} else {
4257  		return nil
4258  	}
4259  }
4260  
4261  func validateOpGetContainerServiceMetricDataInput(v *GetContainerServiceMetricDataInput) error {
4262  	if v == nil {
4263  		return nil
4264  	}
4265  	invalidParams := smithy.InvalidParamsError{Context: "GetContainerServiceMetricDataInput"}
4266  	if v.ServiceName == nil {
4267  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
4268  	}
4269  	if len(v.MetricName) == 0 {
4270  		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
4271  	}
4272  	if v.StartTime == nil {
4273  		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
4274  	}
4275  	if v.EndTime == nil {
4276  		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
4277  	}
4278  	if v.Period == nil {
4279  		invalidParams.Add(smithy.NewErrParamRequired("Period"))
4280  	}
4281  	if v.Statistics == nil {
4282  		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
4283  	}
4284  	if invalidParams.Len() > 0 {
4285  		return invalidParams
4286  	} else {
4287  		return nil
4288  	}
4289  }
4290  
4291  func validateOpGetCostEstimateInput(v *GetCostEstimateInput) error {
4292  	if v == nil {
4293  		return nil
4294  	}
4295  	invalidParams := smithy.InvalidParamsError{Context: "GetCostEstimateInput"}
4296  	if v.ResourceName == nil {
4297  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
4298  	}
4299  	if v.StartTime == nil {
4300  		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
4301  	}
4302  	if v.EndTime == nil {
4303  		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
4304  	}
4305  	if invalidParams.Len() > 0 {
4306  		return invalidParams
4307  	} else {
4308  		return nil
4309  	}
4310  }
4311  
4312  func validateOpGetDiskInput(v *GetDiskInput) error {
4313  	if v == nil {
4314  		return nil
4315  	}
4316  	invalidParams := smithy.InvalidParamsError{Context: "GetDiskInput"}
4317  	if v.DiskName == nil {
4318  		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
4319  	}
4320  	if invalidParams.Len() > 0 {
4321  		return invalidParams
4322  	} else {
4323  		return nil
4324  	}
4325  }
4326  
4327  func validateOpGetDiskSnapshotInput(v *GetDiskSnapshotInput) error {
4328  	if v == nil {
4329  		return nil
4330  	}
4331  	invalidParams := smithy.InvalidParamsError{Context: "GetDiskSnapshotInput"}
4332  	if v.DiskSnapshotName == nil {
4333  		invalidParams.Add(smithy.NewErrParamRequired("DiskSnapshotName"))
4334  	}
4335  	if invalidParams.Len() > 0 {
4336  		return invalidParams
4337  	} else {
4338  		return nil
4339  	}
4340  }
4341  
4342  func validateOpGetDistributionMetricDataInput(v *GetDistributionMetricDataInput) error {
4343  	if v == nil {
4344  		return nil
4345  	}
4346  	invalidParams := smithy.InvalidParamsError{Context: "GetDistributionMetricDataInput"}
4347  	if v.DistributionName == nil {
4348  		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
4349  	}
4350  	if len(v.MetricName) == 0 {
4351  		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
4352  	}
4353  	if v.StartTime == nil {
4354  		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
4355  	}
4356  	if v.EndTime == nil {
4357  		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
4358  	}
4359  	if v.Period == nil {
4360  		invalidParams.Add(smithy.NewErrParamRequired("Period"))
4361  	}
4362  	if len(v.Unit) == 0 {
4363  		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
4364  	}
4365  	if v.Statistics == nil {
4366  		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
4367  	}
4368  	if invalidParams.Len() > 0 {
4369  		return invalidParams
4370  	} else {
4371  		return nil
4372  	}
4373  }
4374  
4375  func validateOpGetDomainInput(v *GetDomainInput) error {
4376  	if v == nil {
4377  		return nil
4378  	}
4379  	invalidParams := smithy.InvalidParamsError{Context: "GetDomainInput"}
4380  	if v.DomainName == nil {
4381  		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
4382  	}
4383  	if invalidParams.Len() > 0 {
4384  		return invalidParams
4385  	} else {
4386  		return nil
4387  	}
4388  }
4389  
4390  func validateOpGetInstanceAccessDetailsInput(v *GetInstanceAccessDetailsInput) error {
4391  	if v == nil {
4392  		return nil
4393  	}
4394  	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceAccessDetailsInput"}
4395  	if v.InstanceName == nil {
4396  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4397  	}
4398  	if invalidParams.Len() > 0 {
4399  		return invalidParams
4400  	} else {
4401  		return nil
4402  	}
4403  }
4404  
4405  func validateOpGetInstanceInput(v *GetInstanceInput) error {
4406  	if v == nil {
4407  		return nil
4408  	}
4409  	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceInput"}
4410  	if v.InstanceName == nil {
4411  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4412  	}
4413  	if invalidParams.Len() > 0 {
4414  		return invalidParams
4415  	} else {
4416  		return nil
4417  	}
4418  }
4419  
4420  func validateOpGetInstanceMetricDataInput(v *GetInstanceMetricDataInput) error {
4421  	if v == nil {
4422  		return nil
4423  	}
4424  	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceMetricDataInput"}
4425  	if v.InstanceName == nil {
4426  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4427  	}
4428  	if len(v.MetricName) == 0 {
4429  		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
4430  	}
4431  	if v.Period == nil {
4432  		invalidParams.Add(smithy.NewErrParamRequired("Period"))
4433  	}
4434  	if v.StartTime == nil {
4435  		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
4436  	}
4437  	if v.EndTime == nil {
4438  		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
4439  	}
4440  	if len(v.Unit) == 0 {
4441  		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
4442  	}
4443  	if v.Statistics == nil {
4444  		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
4445  	}
4446  	if invalidParams.Len() > 0 {
4447  		return invalidParams
4448  	} else {
4449  		return nil
4450  	}
4451  }
4452  
4453  func validateOpGetInstancePortStatesInput(v *GetInstancePortStatesInput) error {
4454  	if v == nil {
4455  		return nil
4456  	}
4457  	invalidParams := smithy.InvalidParamsError{Context: "GetInstancePortStatesInput"}
4458  	if v.InstanceName == nil {
4459  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4460  	}
4461  	if invalidParams.Len() > 0 {
4462  		return invalidParams
4463  	} else {
4464  		return nil
4465  	}
4466  }
4467  
4468  func validateOpGetInstanceSnapshotInput(v *GetInstanceSnapshotInput) error {
4469  	if v == nil {
4470  		return nil
4471  	}
4472  	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceSnapshotInput"}
4473  	if v.InstanceSnapshotName == nil {
4474  		invalidParams.Add(smithy.NewErrParamRequired("InstanceSnapshotName"))
4475  	}
4476  	if invalidParams.Len() > 0 {
4477  		return invalidParams
4478  	} else {
4479  		return nil
4480  	}
4481  }
4482  
4483  func validateOpGetInstanceStateInput(v *GetInstanceStateInput) error {
4484  	if v == nil {
4485  		return nil
4486  	}
4487  	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceStateInput"}
4488  	if v.InstanceName == nil {
4489  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4490  	}
4491  	if invalidParams.Len() > 0 {
4492  		return invalidParams
4493  	} else {
4494  		return nil
4495  	}
4496  }
4497  
4498  func validateOpGetKeyPairInput(v *GetKeyPairInput) error {
4499  	if v == nil {
4500  		return nil
4501  	}
4502  	invalidParams := smithy.InvalidParamsError{Context: "GetKeyPairInput"}
4503  	if v.KeyPairName == nil {
4504  		invalidParams.Add(smithy.NewErrParamRequired("KeyPairName"))
4505  	}
4506  	if invalidParams.Len() > 0 {
4507  		return invalidParams
4508  	} else {
4509  		return nil
4510  	}
4511  }
4512  
4513  func validateOpGetLoadBalancerInput(v *GetLoadBalancerInput) error {
4514  	if v == nil {
4515  		return nil
4516  	}
4517  	invalidParams := smithy.InvalidParamsError{Context: "GetLoadBalancerInput"}
4518  	if v.LoadBalancerName == nil {
4519  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
4520  	}
4521  	if invalidParams.Len() > 0 {
4522  		return invalidParams
4523  	} else {
4524  		return nil
4525  	}
4526  }
4527  
4528  func validateOpGetLoadBalancerMetricDataInput(v *GetLoadBalancerMetricDataInput) error {
4529  	if v == nil {
4530  		return nil
4531  	}
4532  	invalidParams := smithy.InvalidParamsError{Context: "GetLoadBalancerMetricDataInput"}
4533  	if v.LoadBalancerName == nil {
4534  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
4535  	}
4536  	if len(v.MetricName) == 0 {
4537  		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
4538  	}
4539  	if v.Period == nil {
4540  		invalidParams.Add(smithy.NewErrParamRequired("Period"))
4541  	}
4542  	if v.StartTime == nil {
4543  		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
4544  	}
4545  	if v.EndTime == nil {
4546  		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
4547  	}
4548  	if len(v.Unit) == 0 {
4549  		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
4550  	}
4551  	if v.Statistics == nil {
4552  		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
4553  	}
4554  	if invalidParams.Len() > 0 {
4555  		return invalidParams
4556  	} else {
4557  		return nil
4558  	}
4559  }
4560  
4561  func validateOpGetLoadBalancerTlsCertificatesInput(v *GetLoadBalancerTlsCertificatesInput) error {
4562  	if v == nil {
4563  		return nil
4564  	}
4565  	invalidParams := smithy.InvalidParamsError{Context: "GetLoadBalancerTlsCertificatesInput"}
4566  	if v.LoadBalancerName == nil {
4567  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
4568  	}
4569  	if invalidParams.Len() > 0 {
4570  		return invalidParams
4571  	} else {
4572  		return nil
4573  	}
4574  }
4575  
4576  func validateOpGetOperationInput(v *GetOperationInput) error {
4577  	if v == nil {
4578  		return nil
4579  	}
4580  	invalidParams := smithy.InvalidParamsError{Context: "GetOperationInput"}
4581  	if v.OperationId == nil {
4582  		invalidParams.Add(smithy.NewErrParamRequired("OperationId"))
4583  	}
4584  	if invalidParams.Len() > 0 {
4585  		return invalidParams
4586  	} else {
4587  		return nil
4588  	}
4589  }
4590  
4591  func validateOpGetOperationsForResourceInput(v *GetOperationsForResourceInput) error {
4592  	if v == nil {
4593  		return nil
4594  	}
4595  	invalidParams := smithy.InvalidParamsError{Context: "GetOperationsForResourceInput"}
4596  	if v.ResourceName == nil {
4597  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
4598  	}
4599  	if invalidParams.Len() > 0 {
4600  		return invalidParams
4601  	} else {
4602  		return nil
4603  	}
4604  }
4605  
4606  func validateOpGetRelationalDatabaseEventsInput(v *GetRelationalDatabaseEventsInput) error {
4607  	if v == nil {
4608  		return nil
4609  	}
4610  	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseEventsInput"}
4611  	if v.RelationalDatabaseName == nil {
4612  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4613  	}
4614  	if invalidParams.Len() > 0 {
4615  		return invalidParams
4616  	} else {
4617  		return nil
4618  	}
4619  }
4620  
4621  func validateOpGetRelationalDatabaseInput(v *GetRelationalDatabaseInput) error {
4622  	if v == nil {
4623  		return nil
4624  	}
4625  	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseInput"}
4626  	if v.RelationalDatabaseName == nil {
4627  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4628  	}
4629  	if invalidParams.Len() > 0 {
4630  		return invalidParams
4631  	} else {
4632  		return nil
4633  	}
4634  }
4635  
4636  func validateOpGetRelationalDatabaseLogEventsInput(v *GetRelationalDatabaseLogEventsInput) error {
4637  	if v == nil {
4638  		return nil
4639  	}
4640  	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseLogEventsInput"}
4641  	if v.RelationalDatabaseName == nil {
4642  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4643  	}
4644  	if v.LogStreamName == nil {
4645  		invalidParams.Add(smithy.NewErrParamRequired("LogStreamName"))
4646  	}
4647  	if invalidParams.Len() > 0 {
4648  		return invalidParams
4649  	} else {
4650  		return nil
4651  	}
4652  }
4653  
4654  func validateOpGetRelationalDatabaseLogStreamsInput(v *GetRelationalDatabaseLogStreamsInput) error {
4655  	if v == nil {
4656  		return nil
4657  	}
4658  	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseLogStreamsInput"}
4659  	if v.RelationalDatabaseName == nil {
4660  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4661  	}
4662  	if invalidParams.Len() > 0 {
4663  		return invalidParams
4664  	} else {
4665  		return nil
4666  	}
4667  }
4668  
4669  func validateOpGetRelationalDatabaseMasterUserPasswordInput(v *GetRelationalDatabaseMasterUserPasswordInput) error {
4670  	if v == nil {
4671  		return nil
4672  	}
4673  	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseMasterUserPasswordInput"}
4674  	if v.RelationalDatabaseName == nil {
4675  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4676  	}
4677  	if invalidParams.Len() > 0 {
4678  		return invalidParams
4679  	} else {
4680  		return nil
4681  	}
4682  }
4683  
4684  func validateOpGetRelationalDatabaseMetricDataInput(v *GetRelationalDatabaseMetricDataInput) error {
4685  	if v == nil {
4686  		return nil
4687  	}
4688  	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseMetricDataInput"}
4689  	if v.RelationalDatabaseName == nil {
4690  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4691  	}
4692  	if len(v.MetricName) == 0 {
4693  		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
4694  	}
4695  	if v.Period == nil {
4696  		invalidParams.Add(smithy.NewErrParamRequired("Period"))
4697  	}
4698  	if v.StartTime == nil {
4699  		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
4700  	}
4701  	if v.EndTime == nil {
4702  		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
4703  	}
4704  	if len(v.Unit) == 0 {
4705  		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
4706  	}
4707  	if v.Statistics == nil {
4708  		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
4709  	}
4710  	if invalidParams.Len() > 0 {
4711  		return invalidParams
4712  	} else {
4713  		return nil
4714  	}
4715  }
4716  
4717  func validateOpGetRelationalDatabaseParametersInput(v *GetRelationalDatabaseParametersInput) error {
4718  	if v == nil {
4719  		return nil
4720  	}
4721  	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseParametersInput"}
4722  	if v.RelationalDatabaseName == nil {
4723  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4724  	}
4725  	if invalidParams.Len() > 0 {
4726  		return invalidParams
4727  	} else {
4728  		return nil
4729  	}
4730  }
4731  
4732  func validateOpGetRelationalDatabaseSnapshotInput(v *GetRelationalDatabaseSnapshotInput) error {
4733  	if v == nil {
4734  		return nil
4735  	}
4736  	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseSnapshotInput"}
4737  	if v.RelationalDatabaseSnapshotName == nil {
4738  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseSnapshotName"))
4739  	}
4740  	if invalidParams.Len() > 0 {
4741  		return invalidParams
4742  	} else {
4743  		return nil
4744  	}
4745  }
4746  
4747  func validateOpGetSetupHistoryInput(v *GetSetupHistoryInput) error {
4748  	if v == nil {
4749  		return nil
4750  	}
4751  	invalidParams := smithy.InvalidParamsError{Context: "GetSetupHistoryInput"}
4752  	if v.ResourceName == nil {
4753  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
4754  	}
4755  	if invalidParams.Len() > 0 {
4756  		return invalidParams
4757  	} else {
4758  		return nil
4759  	}
4760  }
4761  
4762  func validateOpGetStaticIpInput(v *GetStaticIpInput) error {
4763  	if v == nil {
4764  		return nil
4765  	}
4766  	invalidParams := smithy.InvalidParamsError{Context: "GetStaticIpInput"}
4767  	if v.StaticIpName == nil {
4768  		invalidParams.Add(smithy.NewErrParamRequired("StaticIpName"))
4769  	}
4770  	if invalidParams.Len() > 0 {
4771  		return invalidParams
4772  	} else {
4773  		return nil
4774  	}
4775  }
4776  
4777  func validateOpImportKeyPairInput(v *ImportKeyPairInput) error {
4778  	if v == nil {
4779  		return nil
4780  	}
4781  	invalidParams := smithy.InvalidParamsError{Context: "ImportKeyPairInput"}
4782  	if v.KeyPairName == nil {
4783  		invalidParams.Add(smithy.NewErrParamRequired("KeyPairName"))
4784  	}
4785  	if v.PublicKeyBase64 == nil {
4786  		invalidParams.Add(smithy.NewErrParamRequired("PublicKeyBase64"))
4787  	}
4788  	if invalidParams.Len() > 0 {
4789  		return invalidParams
4790  	} else {
4791  		return nil
4792  	}
4793  }
4794  
4795  func validateOpOpenInstancePublicPortsInput(v *OpenInstancePublicPortsInput) error {
4796  	if v == nil {
4797  		return nil
4798  	}
4799  	invalidParams := smithy.InvalidParamsError{Context: "OpenInstancePublicPortsInput"}
4800  	if v.PortInfo == nil {
4801  		invalidParams.Add(smithy.NewErrParamRequired("PortInfo"))
4802  	}
4803  	if v.InstanceName == nil {
4804  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4805  	}
4806  	if invalidParams.Len() > 0 {
4807  		return invalidParams
4808  	} else {
4809  		return nil
4810  	}
4811  }
4812  
4813  func validateOpPutAlarmInput(v *PutAlarmInput) error {
4814  	if v == nil {
4815  		return nil
4816  	}
4817  	invalidParams := smithy.InvalidParamsError{Context: "PutAlarmInput"}
4818  	if v.AlarmName == nil {
4819  		invalidParams.Add(smithy.NewErrParamRequired("AlarmName"))
4820  	}
4821  	if len(v.MetricName) == 0 {
4822  		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
4823  	}
4824  	if v.MonitoredResourceName == nil {
4825  		invalidParams.Add(smithy.NewErrParamRequired("MonitoredResourceName"))
4826  	}
4827  	if len(v.ComparisonOperator) == 0 {
4828  		invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator"))
4829  	}
4830  	if v.Threshold == nil {
4831  		invalidParams.Add(smithy.NewErrParamRequired("Threshold"))
4832  	}
4833  	if v.EvaluationPeriods == nil {
4834  		invalidParams.Add(smithy.NewErrParamRequired("EvaluationPeriods"))
4835  	}
4836  	if invalidParams.Len() > 0 {
4837  		return invalidParams
4838  	} else {
4839  		return nil
4840  	}
4841  }
4842  
4843  func validateOpPutInstancePublicPortsInput(v *PutInstancePublicPortsInput) error {
4844  	if v == nil {
4845  		return nil
4846  	}
4847  	invalidParams := smithy.InvalidParamsError{Context: "PutInstancePublicPortsInput"}
4848  	if v.PortInfos == nil {
4849  		invalidParams.Add(smithy.NewErrParamRequired("PortInfos"))
4850  	}
4851  	if v.InstanceName == nil {
4852  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4853  	}
4854  	if invalidParams.Len() > 0 {
4855  		return invalidParams
4856  	} else {
4857  		return nil
4858  	}
4859  }
4860  
4861  func validateOpRebootInstanceInput(v *RebootInstanceInput) error {
4862  	if v == nil {
4863  		return nil
4864  	}
4865  	invalidParams := smithy.InvalidParamsError{Context: "RebootInstanceInput"}
4866  	if v.InstanceName == nil {
4867  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4868  	}
4869  	if invalidParams.Len() > 0 {
4870  		return invalidParams
4871  	} else {
4872  		return nil
4873  	}
4874  }
4875  
4876  func validateOpRebootRelationalDatabaseInput(v *RebootRelationalDatabaseInput) error {
4877  	if v == nil {
4878  		return nil
4879  	}
4880  	invalidParams := smithy.InvalidParamsError{Context: "RebootRelationalDatabaseInput"}
4881  	if v.RelationalDatabaseName == nil {
4882  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
4883  	}
4884  	if invalidParams.Len() > 0 {
4885  		return invalidParams
4886  	} else {
4887  		return nil
4888  	}
4889  }
4890  
4891  func validateOpRegisterContainerImageInput(v *RegisterContainerImageInput) error {
4892  	if v == nil {
4893  		return nil
4894  	}
4895  	invalidParams := smithy.InvalidParamsError{Context: "RegisterContainerImageInput"}
4896  	if v.ServiceName == nil {
4897  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
4898  	}
4899  	if v.Label == nil {
4900  		invalidParams.Add(smithy.NewErrParamRequired("Label"))
4901  	}
4902  	if v.Digest == nil {
4903  		invalidParams.Add(smithy.NewErrParamRequired("Digest"))
4904  	}
4905  	if invalidParams.Len() > 0 {
4906  		return invalidParams
4907  	} else {
4908  		return nil
4909  	}
4910  }
4911  
4912  func validateOpReleaseStaticIpInput(v *ReleaseStaticIpInput) error {
4913  	if v == nil {
4914  		return nil
4915  	}
4916  	invalidParams := smithy.InvalidParamsError{Context: "ReleaseStaticIpInput"}
4917  	if v.StaticIpName == nil {
4918  		invalidParams.Add(smithy.NewErrParamRequired("StaticIpName"))
4919  	}
4920  	if invalidParams.Len() > 0 {
4921  		return invalidParams
4922  	} else {
4923  		return nil
4924  	}
4925  }
4926  
4927  func validateOpSendContactMethodVerificationInput(v *SendContactMethodVerificationInput) error {
4928  	if v == nil {
4929  		return nil
4930  	}
4931  	invalidParams := smithy.InvalidParamsError{Context: "SendContactMethodVerificationInput"}
4932  	if len(v.Protocol) == 0 {
4933  		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
4934  	}
4935  	if invalidParams.Len() > 0 {
4936  		return invalidParams
4937  	} else {
4938  		return nil
4939  	}
4940  }
4941  
4942  func validateOpSetIpAddressTypeInput(v *SetIpAddressTypeInput) error {
4943  	if v == nil {
4944  		return nil
4945  	}
4946  	invalidParams := smithy.InvalidParamsError{Context: "SetIpAddressTypeInput"}
4947  	if len(v.ResourceType) == 0 {
4948  		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
4949  	}
4950  	if v.ResourceName == nil {
4951  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
4952  	}
4953  	if len(v.IpAddressType) == 0 {
4954  		invalidParams.Add(smithy.NewErrParamRequired("IpAddressType"))
4955  	}
4956  	if invalidParams.Len() > 0 {
4957  		return invalidParams
4958  	} else {
4959  		return nil
4960  	}
4961  }
4962  
4963  func validateOpSetResourceAccessForBucketInput(v *SetResourceAccessForBucketInput) error {
4964  	if v == nil {
4965  		return nil
4966  	}
4967  	invalidParams := smithy.InvalidParamsError{Context: "SetResourceAccessForBucketInput"}
4968  	if v.ResourceName == nil {
4969  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
4970  	}
4971  	if v.BucketName == nil {
4972  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
4973  	}
4974  	if len(v.Access) == 0 {
4975  		invalidParams.Add(smithy.NewErrParamRequired("Access"))
4976  	}
4977  	if invalidParams.Len() > 0 {
4978  		return invalidParams
4979  	} else {
4980  		return nil
4981  	}
4982  }
4983  
4984  func validateOpSetupInstanceHttpsInput(v *SetupInstanceHttpsInput) error {
4985  	if v == nil {
4986  		return nil
4987  	}
4988  	invalidParams := smithy.InvalidParamsError{Context: "SetupInstanceHttpsInput"}
4989  	if v.InstanceName == nil {
4990  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
4991  	}
4992  	if v.EmailAddress == nil {
4993  		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
4994  	}
4995  	if v.DomainNames == nil {
4996  		invalidParams.Add(smithy.NewErrParamRequired("DomainNames"))
4997  	}
4998  	if len(v.CertificateProvider) == 0 {
4999  		invalidParams.Add(smithy.NewErrParamRequired("CertificateProvider"))
5000  	}
5001  	if invalidParams.Len() > 0 {
5002  		return invalidParams
5003  	} else {
5004  		return nil
5005  	}
5006  }
5007  
5008  func validateOpStartGUISessionInput(v *StartGUISessionInput) error {
5009  	if v == nil {
5010  		return nil
5011  	}
5012  	invalidParams := smithy.InvalidParamsError{Context: "StartGUISessionInput"}
5013  	if v.ResourceName == nil {
5014  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
5015  	}
5016  	if invalidParams.Len() > 0 {
5017  		return invalidParams
5018  	} else {
5019  		return nil
5020  	}
5021  }
5022  
5023  func validateOpStartInstanceInput(v *StartInstanceInput) error {
5024  	if v == nil {
5025  		return nil
5026  	}
5027  	invalidParams := smithy.InvalidParamsError{Context: "StartInstanceInput"}
5028  	if v.InstanceName == nil {
5029  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
5030  	}
5031  	if invalidParams.Len() > 0 {
5032  		return invalidParams
5033  	} else {
5034  		return nil
5035  	}
5036  }
5037  
5038  func validateOpStartRelationalDatabaseInput(v *StartRelationalDatabaseInput) error {
5039  	if v == nil {
5040  		return nil
5041  	}
5042  	invalidParams := smithy.InvalidParamsError{Context: "StartRelationalDatabaseInput"}
5043  	if v.RelationalDatabaseName == nil {
5044  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
5045  	}
5046  	if invalidParams.Len() > 0 {
5047  		return invalidParams
5048  	} else {
5049  		return nil
5050  	}
5051  }
5052  
5053  func validateOpStopGUISessionInput(v *StopGUISessionInput) error {
5054  	if v == nil {
5055  		return nil
5056  	}
5057  	invalidParams := smithy.InvalidParamsError{Context: "StopGUISessionInput"}
5058  	if v.ResourceName == nil {
5059  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
5060  	}
5061  	if invalidParams.Len() > 0 {
5062  		return invalidParams
5063  	} else {
5064  		return nil
5065  	}
5066  }
5067  
5068  func validateOpStopInstanceInput(v *StopInstanceInput) error {
5069  	if v == nil {
5070  		return nil
5071  	}
5072  	invalidParams := smithy.InvalidParamsError{Context: "StopInstanceInput"}
5073  	if v.InstanceName == nil {
5074  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
5075  	}
5076  	if invalidParams.Len() > 0 {
5077  		return invalidParams
5078  	} else {
5079  		return nil
5080  	}
5081  }
5082  
5083  func validateOpStopRelationalDatabaseInput(v *StopRelationalDatabaseInput) error {
5084  	if v == nil {
5085  		return nil
5086  	}
5087  	invalidParams := smithy.InvalidParamsError{Context: "StopRelationalDatabaseInput"}
5088  	if v.RelationalDatabaseName == nil {
5089  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
5090  	}
5091  	if invalidParams.Len() > 0 {
5092  		return invalidParams
5093  	} else {
5094  		return nil
5095  	}
5096  }
5097  
5098  func validateOpTagResourceInput(v *TagResourceInput) error {
5099  	if v == nil {
5100  		return nil
5101  	}
5102  	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
5103  	if v.ResourceName == nil {
5104  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
5105  	}
5106  	if v.Tags == nil {
5107  		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
5108  	}
5109  	if invalidParams.Len() > 0 {
5110  		return invalidParams
5111  	} else {
5112  		return nil
5113  	}
5114  }
5115  
5116  func validateOpTestAlarmInput(v *TestAlarmInput) error {
5117  	if v == nil {
5118  		return nil
5119  	}
5120  	invalidParams := smithy.InvalidParamsError{Context: "TestAlarmInput"}
5121  	if v.AlarmName == nil {
5122  		invalidParams.Add(smithy.NewErrParamRequired("AlarmName"))
5123  	}
5124  	if len(v.State) == 0 {
5125  		invalidParams.Add(smithy.NewErrParamRequired("State"))
5126  	}
5127  	if invalidParams.Len() > 0 {
5128  		return invalidParams
5129  	} else {
5130  		return nil
5131  	}
5132  }
5133  
5134  func validateOpUntagResourceInput(v *UntagResourceInput) error {
5135  	if v == nil {
5136  		return nil
5137  	}
5138  	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
5139  	if v.ResourceName == nil {
5140  		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
5141  	}
5142  	if v.TagKeys == nil {
5143  		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
5144  	}
5145  	if invalidParams.Len() > 0 {
5146  		return invalidParams
5147  	} else {
5148  		return nil
5149  	}
5150  }
5151  
5152  func validateOpUpdateBucketBundleInput(v *UpdateBucketBundleInput) error {
5153  	if v == nil {
5154  		return nil
5155  	}
5156  	invalidParams := smithy.InvalidParamsError{Context: "UpdateBucketBundleInput"}
5157  	if v.BucketName == nil {
5158  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
5159  	}
5160  	if v.BundleId == nil {
5161  		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
5162  	}
5163  	if invalidParams.Len() > 0 {
5164  		return invalidParams
5165  	} else {
5166  		return nil
5167  	}
5168  }
5169  
5170  func validateOpUpdateBucketInput(v *UpdateBucketInput) error {
5171  	if v == nil {
5172  		return nil
5173  	}
5174  	invalidParams := smithy.InvalidParamsError{Context: "UpdateBucketInput"}
5175  	if v.BucketName == nil {
5176  		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
5177  	}
5178  	if v.AccessLogConfig != nil {
5179  		if err := validateBucketAccessLogConfig(v.AccessLogConfig); err != nil {
5180  			invalidParams.AddNested("AccessLogConfig", err.(smithy.InvalidParamsError))
5181  		}
5182  	}
5183  	if v.Cors != nil {
5184  		if err := validateBucketCorsConfig(v.Cors); err != nil {
5185  			invalidParams.AddNested("Cors", err.(smithy.InvalidParamsError))
5186  		}
5187  	}
5188  	if invalidParams.Len() > 0 {
5189  		return invalidParams
5190  	} else {
5191  		return nil
5192  	}
5193  }
5194  
5195  func validateOpUpdateContainerServiceInput(v *UpdateContainerServiceInput) error {
5196  	if v == nil {
5197  		return nil
5198  	}
5199  	invalidParams := smithy.InvalidParamsError{Context: "UpdateContainerServiceInput"}
5200  	if v.ServiceName == nil {
5201  		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
5202  	}
5203  	if invalidParams.Len() > 0 {
5204  		return invalidParams
5205  	} else {
5206  		return nil
5207  	}
5208  }
5209  
5210  func validateOpUpdateDistributionInput(v *UpdateDistributionInput) error {
5211  	if v == nil {
5212  		return nil
5213  	}
5214  	invalidParams := smithy.InvalidParamsError{Context: "UpdateDistributionInput"}
5215  	if v.DistributionName == nil {
5216  		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
5217  	}
5218  	if invalidParams.Len() > 0 {
5219  		return invalidParams
5220  	} else {
5221  		return nil
5222  	}
5223  }
5224  
5225  func validateOpUpdateDomainEntryInput(v *UpdateDomainEntryInput) error {
5226  	if v == nil {
5227  		return nil
5228  	}
5229  	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainEntryInput"}
5230  	if v.DomainName == nil {
5231  		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
5232  	}
5233  	if v.DomainEntry == nil {
5234  		invalidParams.Add(smithy.NewErrParamRequired("DomainEntry"))
5235  	}
5236  	if invalidParams.Len() > 0 {
5237  		return invalidParams
5238  	} else {
5239  		return nil
5240  	}
5241  }
5242  
5243  func validateOpUpdateInstanceMetadataOptionsInput(v *UpdateInstanceMetadataOptionsInput) error {
5244  	if v == nil {
5245  		return nil
5246  	}
5247  	invalidParams := smithy.InvalidParamsError{Context: "UpdateInstanceMetadataOptionsInput"}
5248  	if v.InstanceName == nil {
5249  		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
5250  	}
5251  	if invalidParams.Len() > 0 {
5252  		return invalidParams
5253  	} else {
5254  		return nil
5255  	}
5256  }
5257  
5258  func validateOpUpdateLoadBalancerAttributeInput(v *UpdateLoadBalancerAttributeInput) error {
5259  	if v == nil {
5260  		return nil
5261  	}
5262  	invalidParams := smithy.InvalidParamsError{Context: "UpdateLoadBalancerAttributeInput"}
5263  	if v.LoadBalancerName == nil {
5264  		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
5265  	}
5266  	if len(v.AttributeName) == 0 {
5267  		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
5268  	}
5269  	if v.AttributeValue == nil {
5270  		invalidParams.Add(smithy.NewErrParamRequired("AttributeValue"))
5271  	}
5272  	if invalidParams.Len() > 0 {
5273  		return invalidParams
5274  	} else {
5275  		return nil
5276  	}
5277  }
5278  
5279  func validateOpUpdateRelationalDatabaseInput(v *UpdateRelationalDatabaseInput) error {
5280  	if v == nil {
5281  		return nil
5282  	}
5283  	invalidParams := smithy.InvalidParamsError{Context: "UpdateRelationalDatabaseInput"}
5284  	if v.RelationalDatabaseName == nil {
5285  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
5286  	}
5287  	if invalidParams.Len() > 0 {
5288  		return invalidParams
5289  	} else {
5290  		return nil
5291  	}
5292  }
5293  
5294  func validateOpUpdateRelationalDatabaseParametersInput(v *UpdateRelationalDatabaseParametersInput) error {
5295  	if v == nil {
5296  		return nil
5297  	}
5298  	invalidParams := smithy.InvalidParamsError{Context: "UpdateRelationalDatabaseParametersInput"}
5299  	if v.RelationalDatabaseName == nil {
5300  		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
5301  	}
5302  	if v.Parameters == nil {
5303  		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
5304  	}
5305  	if invalidParams.Len() > 0 {
5306  		return invalidParams
5307  	} else {
5308  		return nil
5309  	}
5310  }
5311