// Code generated by smithy-go-codegen DO NOT EDIT.

package apigateway

import (
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/apigateway/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpCreateAuthorizer struct {
}

func (*validateOpCreateAuthorizer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateAuthorizerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateAuthorizerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateBasePathMapping struct {
}

func (*validateOpCreateBasePathMapping) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateBasePathMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateBasePathMappingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateBasePathMappingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateDeployment struct {
}

func (*validateOpCreateDeployment) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDeploymentInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDeploymentInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateDocumentationPart struct {
}

func (*validateOpCreateDocumentationPart) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateDocumentationPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDocumentationPartInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDocumentationPartInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateDocumentationVersion struct {
}

func (*validateOpCreateDocumentationVersion) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateDocumentationVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDocumentationVersionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDocumentationVersionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateDomainName struct {
}

func (*validateOpCreateDomainName) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDomainNameInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDomainNameInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateModel struct {
}

func (*validateOpCreateModel) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateModelInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateModelInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateRequestValidator struct {
}

func (*validateOpCreateRequestValidator) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateRequestValidator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRequestValidatorInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRequestValidatorInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateResource struct {
}

func (*validateOpCreateResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateRestApi struct {
}

func (*validateOpCreateRestApi) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRestApiInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRestApiInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateStage struct {
}

func (*validateOpCreateStage) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateStageInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateStageInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateUsagePlan struct {
}

func (*validateOpCreateUsagePlan) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateUsagePlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateUsagePlanInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateUsagePlanInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateUsagePlanKey struct {
}

func (*validateOpCreateUsagePlanKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateUsagePlanKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateUsagePlanKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateUsagePlanKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateVpcLink struct {
}

func (*validateOpCreateVpcLink) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateVpcLinkInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateVpcLinkInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteApiKey struct {
}

func (*validateOpDeleteApiKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteApiKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteApiKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteApiKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteAuthorizer struct {
}

func (*validateOpDeleteAuthorizer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteAuthorizerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteAuthorizerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteBasePathMapping struct {
}

func (*validateOpDeleteBasePathMapping) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteBasePathMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteBasePathMappingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteBasePathMappingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteClientCertificate struct {
}

func (*validateOpDeleteClientCertificate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteClientCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteClientCertificateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteClientCertificateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteDeployment struct {
}

func (*validateOpDeleteDeployment) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteDeploymentInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteDeploymentInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteDocumentationPart struct {
}

func (*validateOpDeleteDocumentationPart) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteDocumentationPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteDocumentationPartInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteDocumentationPartInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteDocumentationVersion struct {
}

func (*validateOpDeleteDocumentationVersion) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteDocumentationVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteDocumentationVersionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteDocumentationVersionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteDomainName struct {
}

func (*validateOpDeleteDomainName) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteDomainNameInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteDomainNameInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteGatewayResponse struct {
}

func (*validateOpDeleteGatewayResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteGatewayResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteGatewayResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteGatewayResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteIntegration struct {
}

func (*validateOpDeleteIntegration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteIntegrationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteIntegrationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteIntegrationResponse struct {
}

func (*validateOpDeleteIntegrationResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteIntegrationResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteIntegrationResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteMethod struct {
}

func (*validateOpDeleteMethod) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteMethodInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteMethodInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteMethodResponse struct {
}

func (*validateOpDeleteMethodResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteMethodResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteMethodResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteMethodResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteModel struct {
}

func (*validateOpDeleteModel) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteModelInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteModelInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRequestValidator struct {
}

func (*validateOpDeleteRequestValidator) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRequestValidator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRequestValidatorInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRequestValidatorInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteResource struct {
}

func (*validateOpDeleteResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRestApi struct {
}

func (*validateOpDeleteRestApi) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRestApiInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRestApiInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteStage struct {
}

func (*validateOpDeleteStage) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteStageInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteStageInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUsagePlan struct {
}

func (*validateOpDeleteUsagePlan) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUsagePlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUsagePlanInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUsagePlanInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUsagePlanKey struct {
}

func (*validateOpDeleteUsagePlanKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUsagePlanKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUsagePlanKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUsagePlanKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteVpcLink struct {
}

func (*validateOpDeleteVpcLink) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteVpcLinkInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteVpcLinkInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpFlushStageAuthorizersCache struct {
}

func (*validateOpFlushStageAuthorizersCache) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpFlushStageAuthorizersCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*FlushStageAuthorizersCacheInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpFlushStageAuthorizersCacheInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpFlushStageCache struct {
}

func (*validateOpFlushStageCache) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpFlushStageCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*FlushStageCacheInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpFlushStageCacheInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetApiKey struct {
}

func (*validateOpGetApiKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetApiKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetApiKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetApiKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetAuthorizer struct {
}

func (*validateOpGetAuthorizer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetAuthorizerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetAuthorizerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetAuthorizers struct {
}

func (*validateOpGetAuthorizers) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetAuthorizers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetAuthorizersInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetAuthorizersInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetBasePathMapping struct {
}

func (*validateOpGetBasePathMapping) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetBasePathMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetBasePathMappingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetBasePathMappingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetBasePathMappings struct {
}

func (*validateOpGetBasePathMappings) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetBasePathMappings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetBasePathMappingsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetBasePathMappingsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetClientCertificate struct {
}

func (*validateOpGetClientCertificate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetClientCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetClientCertificateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetClientCertificateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDeployment struct {
}

func (*validateOpGetDeployment) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDeploymentInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDeploymentInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDeployments struct {
}

func (*validateOpGetDeployments) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDeploymentsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDeploymentsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDocumentationPart struct {
}

func (*validateOpGetDocumentationPart) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDocumentationPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDocumentationPartInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDocumentationPartInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDocumentationParts struct {
}

func (*validateOpGetDocumentationParts) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDocumentationParts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDocumentationPartsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDocumentationPartsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDocumentationVersion struct {
}

func (*validateOpGetDocumentationVersion) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDocumentationVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDocumentationVersionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDocumentationVersionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDocumentationVersions struct {
}

func (*validateOpGetDocumentationVersions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDocumentationVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDocumentationVersionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDocumentationVersionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDomainName struct {
}

func (*validateOpGetDomainName) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDomainNameInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDomainNameInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetExport struct {
}

func (*validateOpGetExport) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetExport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetExportInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetExportInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetGatewayResponse struct {
}

func (*validateOpGetGatewayResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetGatewayResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetGatewayResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetGatewayResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetGatewayResponses struct {
}

func (*validateOpGetGatewayResponses) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetGatewayResponses) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetGatewayResponsesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetGatewayResponsesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIntegration struct {
}

func (*validateOpGetIntegration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIntegrationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIntegrationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIntegrationResponse struct {
}

func (*validateOpGetIntegrationResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIntegrationResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIntegrationResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetMethod struct {
}

func (*validateOpGetMethod) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetMethodInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetMethodInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetMethodResponse struct {
}

func (*validateOpGetMethodResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetMethodResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetMethodResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetMethodResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetModel struct {
}

func (*validateOpGetModel) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetModelInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetModelInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetModels struct {
}

func (*validateOpGetModels) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetModels) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetModelsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetModelsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetModelTemplate struct {
}

func (*validateOpGetModelTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetModelTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetModelTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetModelTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRequestValidator struct {
}

func (*validateOpGetRequestValidator) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRequestValidator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRequestValidatorInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRequestValidatorInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRequestValidators struct {
}

func (*validateOpGetRequestValidators) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRequestValidators) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRequestValidatorsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRequestValidatorsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetResource struct {
}

func (*validateOpGetResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetResources struct {
}

func (*validateOpGetResources) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetResourcesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetResourcesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRestApi struct {
}

func (*validateOpGetRestApi) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRestApiInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRestApiInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetSdk struct {
}

func (*validateOpGetSdk) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetSdk) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetSdkInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetSdkInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetSdkType struct {
}

func (*validateOpGetSdkType) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetSdkType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetSdkTypeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetSdkTypeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetStage struct {
}

func (*validateOpGetStage) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetStageInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetStageInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetStages struct {
}

func (*validateOpGetStages) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetStages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetStagesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetStagesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetTags struct {
}

func (*validateOpGetTags) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetTagsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetTagsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUsage struct {
}

func (*validateOpGetUsage) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUsage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUsageInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUsageInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUsagePlan struct {
}

func (*validateOpGetUsagePlan) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUsagePlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUsagePlanInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUsagePlanInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUsagePlanKey struct {
}

func (*validateOpGetUsagePlanKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUsagePlanKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUsagePlanKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUsagePlanKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUsagePlanKeys struct {
}

func (*validateOpGetUsagePlanKeys) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUsagePlanKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUsagePlanKeysInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUsagePlanKeysInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetVpcLink struct {
}

func (*validateOpGetVpcLink) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetVpcLinkInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetVpcLinkInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpImportApiKeys struct {
}

func (*validateOpImportApiKeys) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpImportApiKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ImportApiKeysInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpImportApiKeysInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpImportDocumentationParts struct {
}

func (*validateOpImportDocumentationParts) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpImportDocumentationParts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ImportDocumentationPartsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpImportDocumentationPartsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpImportRestApi struct {
}

func (*validateOpImportRestApi) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpImportRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ImportRestApiInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpImportRestApiInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutGatewayResponse struct {
}

func (*validateOpPutGatewayResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutGatewayResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutGatewayResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutGatewayResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutIntegration struct {
}

func (*validateOpPutIntegration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutIntegrationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutIntegrationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutIntegrationResponse struct {
}

func (*validateOpPutIntegrationResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutIntegrationResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutIntegrationResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutMethod struct {
}

func (*validateOpPutMethod) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutMethodInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutMethodInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutMethodResponse struct {
}

func (*validateOpPutMethodResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutMethodResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutMethodResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutMethodResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutRestApi struct {
}

func (*validateOpPutRestApi) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutRestApiInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutRestApiInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTagResource struct {
}

func (*validateOpTagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTestInvokeAuthorizer struct {
}

func (*validateOpTestInvokeAuthorizer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTestInvokeAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TestInvokeAuthorizerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTestInvokeAuthorizerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTestInvokeMethod struct {
}

func (*validateOpTestInvokeMethod) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTestInvokeMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TestInvokeMethodInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTestInvokeMethodInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUntagResource struct {
}

func (*validateOpUntagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UntagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUntagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateApiKey struct {
}

func (*validateOpUpdateApiKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateApiKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateApiKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateApiKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateAuthorizer struct {
}

func (*validateOpUpdateAuthorizer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateAuthorizerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateAuthorizerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateBasePathMapping struct {
}

func (*validateOpUpdateBasePathMapping) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateBasePathMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateBasePathMappingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateBasePathMappingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateClientCertificate struct {
}

func (*validateOpUpdateClientCertificate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateClientCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateClientCertificateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateClientCertificateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDeployment struct {
}

func (*validateOpUpdateDeployment) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDeploymentInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDeploymentInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDocumentationPart struct {
}

func (*validateOpUpdateDocumentationPart) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDocumentationPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDocumentationPartInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDocumentationPartInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDocumentationVersion struct {
}

func (*validateOpUpdateDocumentationVersion) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDocumentationVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDocumentationVersionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDocumentationVersionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDomainName struct {
}

func (*validateOpUpdateDomainName) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDomainNameInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDomainNameInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateGatewayResponse struct {
}

func (*validateOpUpdateGatewayResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateGatewayResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateGatewayResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateGatewayResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateIntegration struct {
}

func (*validateOpUpdateIntegration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateIntegrationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateIntegrationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateIntegrationResponse struct {
}

func (*validateOpUpdateIntegrationResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateIntegrationResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateIntegrationResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateMethod struct {
}

func (*validateOpUpdateMethod) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateMethodInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateMethodInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateMethodResponse struct {
}

func (*validateOpUpdateMethodResponse) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateMethodResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateMethodResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateMethodResponseInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateModel struct {
}

func (*validateOpUpdateModel) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateModelInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateModelInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateRequestValidator struct {
}

func (*validateOpUpdateRequestValidator) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateRequestValidator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRequestValidatorInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRequestValidatorInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateResource struct {
}

func (*validateOpUpdateResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateRestApi struct {
}

func (*validateOpUpdateRestApi) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRestApiInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRestApiInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateStage struct {
}

func (*validateOpUpdateStage) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateStageInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateStageInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateUsage struct {
}

func (*validateOpUpdateUsage) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateUsage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateUsageInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateUsageInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateUsagePlan struct {
}

func (*validateOpUpdateUsagePlan) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateUsagePlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateUsagePlanInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateUsagePlanInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateVpcLink struct {
}

func (*validateOpUpdateVpcLink) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateVpcLinkInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateVpcLinkInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

func addOpCreateAuthorizerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateAuthorizer{}, middleware.After)
}

func addOpCreateBasePathMappingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateBasePathMapping{}, middleware.After)
}

func addOpCreateDeploymentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDeployment{}, middleware.After)
}

func addOpCreateDocumentationPartValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDocumentationPart{}, middleware.After)
}

func addOpCreateDocumentationVersionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDocumentationVersion{}, middleware.After)
}

func addOpCreateDomainNameValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDomainName{}, middleware.After)
}

func addOpCreateModelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateModel{}, middleware.After)
}

func addOpCreateRequestValidatorValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRequestValidator{}, middleware.After)
}

func addOpCreateResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateResource{}, middleware.After)
}

func addOpCreateRestApiValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRestApi{}, middleware.After)
}

func addOpCreateStageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateStage{}, middleware.After)
}

func addOpCreateUsagePlanValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateUsagePlan{}, middleware.After)
}

func addOpCreateUsagePlanKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateUsagePlanKey{}, middleware.After)
}

func addOpCreateVpcLinkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpcLink{}, middleware.After)
}

func addOpDeleteApiKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteApiKey{}, middleware.After)
}

func addOpDeleteAuthorizerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteAuthorizer{}, middleware.After)
}

func addOpDeleteBasePathMappingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteBasePathMapping{}, middleware.After)
}

func addOpDeleteClientCertificateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteClientCertificate{}, middleware.After)
}

func addOpDeleteDeploymentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDeployment{}, middleware.After)
}

func addOpDeleteDocumentationPartValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDocumentationPart{}, middleware.After)
}

func addOpDeleteDocumentationVersionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDocumentationVersion{}, middleware.After)
}

func addOpDeleteDomainNameValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDomainName{}, middleware.After)
}

func addOpDeleteGatewayResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteGatewayResponse{}, middleware.After)
}

func addOpDeleteIntegrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIntegration{}, middleware.After)
}

func addOpDeleteIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIntegrationResponse{}, middleware.After)
}

func addOpDeleteMethodValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteMethod{}, middleware.After)
}

func addOpDeleteMethodResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteMethodResponse{}, middleware.After)
}

func addOpDeleteModelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteModel{}, middleware.After)
}

func addOpDeleteRequestValidatorValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRequestValidator{}, middleware.After)
}

func addOpDeleteResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteResource{}, middleware.After)
}

func addOpDeleteRestApiValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRestApi{}, middleware.After)
}

func addOpDeleteStageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteStage{}, middleware.After)
}

func addOpDeleteUsagePlanValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUsagePlan{}, middleware.After)
}

func addOpDeleteUsagePlanKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUsagePlanKey{}, middleware.After)
}

func addOpDeleteVpcLinkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpcLink{}, middleware.After)
}

func addOpFlushStageAuthorizersCacheValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpFlushStageAuthorizersCache{}, middleware.After)
}

func addOpFlushStageCacheValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpFlushStageCache{}, middleware.After)
}

func addOpGetApiKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetApiKey{}, middleware.After)
}

func addOpGetAuthorizerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAuthorizer{}, middleware.After)
}

func addOpGetAuthorizersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAuthorizers{}, middleware.After)
}

func addOpGetBasePathMappingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetBasePathMapping{}, middleware.After)
}

func addOpGetBasePathMappingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetBasePathMappings{}, middleware.After)
}

func addOpGetClientCertificateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetClientCertificate{}, middleware.After)
}

func addOpGetDeploymentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDeployment{}, middleware.After)
}

func addOpGetDeploymentsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDeployments{}, middleware.After)
}

func addOpGetDocumentationPartValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDocumentationPart{}, middleware.After)
}

func addOpGetDocumentationPartsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDocumentationParts{}, middleware.After)
}

func addOpGetDocumentationVersionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDocumentationVersion{}, middleware.After)
}

func addOpGetDocumentationVersionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDocumentationVersions{}, middleware.After)
}

func addOpGetDomainNameValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDomainName{}, middleware.After)
}

func addOpGetExportValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetExport{}, middleware.After)
}

func addOpGetGatewayResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetGatewayResponse{}, middleware.After)
}

func addOpGetGatewayResponsesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetGatewayResponses{}, middleware.After)
}

func addOpGetIntegrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIntegration{}, middleware.After)
}

func addOpGetIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIntegrationResponse{}, middleware.After)
}

func addOpGetMethodValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetMethod{}, middleware.After)
}

func addOpGetMethodResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetMethodResponse{}, middleware.After)
}

func addOpGetModelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetModel{}, middleware.After)
}

func addOpGetModelsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetModels{}, middleware.After)
}

func addOpGetModelTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetModelTemplate{}, middleware.After)
}

func addOpGetRequestValidatorValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRequestValidator{}, middleware.After)
}

func addOpGetRequestValidatorsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRequestValidators{}, middleware.After)
}

func addOpGetResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetResource{}, middleware.After)
}

func addOpGetResourcesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetResources{}, middleware.After)
}

func addOpGetRestApiValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRestApi{}, middleware.After)
}

func addOpGetSdkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSdk{}, middleware.After)
}

func addOpGetSdkTypeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSdkType{}, middleware.After)
}

func addOpGetStageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetStage{}, middleware.After)
}

func addOpGetStagesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetStages{}, middleware.After)
}

func addOpGetTagsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTags{}, middleware.After)
}

func addOpGetUsageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUsage{}, middleware.After)
}

func addOpGetUsagePlanValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUsagePlan{}, middleware.After)
}

func addOpGetUsagePlanKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUsagePlanKey{}, middleware.After)
}

func addOpGetUsagePlanKeysValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUsagePlanKeys{}, middleware.After)
}

func addOpGetVpcLinkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVpcLink{}, middleware.After)
}

func addOpImportApiKeysValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportApiKeys{}, middleware.After)
}

func addOpImportDocumentationPartsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportDocumentationParts{}, middleware.After)
}

func addOpImportRestApiValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportRestApi{}, middleware.After)
}

func addOpPutGatewayResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutGatewayResponse{}, middleware.After)
}

func addOpPutIntegrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutIntegration{}, middleware.After)
}

func addOpPutIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutIntegrationResponse{}, middleware.After)
}

func addOpPutMethodValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutMethod{}, middleware.After)
}

func addOpPutMethodResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutMethodResponse{}, middleware.After)
}

func addOpPutRestApiValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutRestApi{}, middleware.After)
}

func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}

func addOpTestInvokeAuthorizerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTestInvokeAuthorizer{}, middleware.After)
}

func addOpTestInvokeMethodValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTestInvokeMethod{}, middleware.After)
}

func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}

func addOpUpdateApiKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateApiKey{}, middleware.After)
}

func addOpUpdateAuthorizerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAuthorizer{}, middleware.After)
}

func addOpUpdateBasePathMappingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateBasePathMapping{}, middleware.After)
}

func addOpUpdateClientCertificateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateClientCertificate{}, middleware.After)
}

func addOpUpdateDeploymentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDeployment{}, middleware.After)
}

func addOpUpdateDocumentationPartValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDocumentationPart{}, middleware.After)
}

func addOpUpdateDocumentationVersionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDocumentationVersion{}, middleware.After)
}

func addOpUpdateDomainNameValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDomainName{}, middleware.After)
}

func addOpUpdateGatewayResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateGatewayResponse{}, middleware.After)
}

func addOpUpdateIntegrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateIntegration{}, middleware.After)
}

func addOpUpdateIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateIntegrationResponse{}, middleware.After)
}

func addOpUpdateMethodValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateMethod{}, middleware.After)
}

func addOpUpdateMethodResponseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateMethodResponse{}, middleware.After)
}

func addOpUpdateModelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateModel{}, middleware.After)
}

func addOpUpdateRequestValidatorValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRequestValidator{}, middleware.After)
}

func addOpUpdateResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateResource{}, middleware.After)
}

func addOpUpdateRestApiValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRestApi{}, middleware.After)
}

func addOpUpdateStageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateStage{}, middleware.After)
}

func addOpUpdateUsageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUsage{}, middleware.After)
}

func addOpUpdateUsagePlanValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUsagePlan{}, middleware.After)
}

func addOpUpdateVpcLinkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateVpcLink{}, middleware.After)
}

func validateDocumentationPartLocation(v *types.DocumentationPartLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentationPartLocation"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAuthorizerInput(v *CreateAuthorizerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAuthorizerInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBasePathMappingInput(v *CreateBasePathMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBasePathMappingInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDeploymentInput(v *CreateDeploymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDocumentationPartInput(v *CreateDocumentationPartInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDocumentationPartInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	} else if v.Location != nil {
		if err := validateDocumentationPartLocation(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if v.Properties == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Properties"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDocumentationVersionInput(v *CreateDocumentationVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDocumentationVersionInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DocumentationVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentationVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDomainNameInput(v *CreateDomainNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainNameInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateModelInput(v *CreateModelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateModelInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ContentType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRequestValidatorInput(v *CreateRequestValidatorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRequestValidatorInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateResourceInput(v *CreateResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResourceInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ParentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentId"))
	}
	if v.PathPart == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PathPart"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRestApiInput(v *CreateRestApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRestApiInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStageInput(v *CreateStageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStageInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	if v.DeploymentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUsagePlanInput(v *CreateUsagePlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUsagePlanInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUsagePlanKeyInput(v *CreateUsagePlanKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUsagePlanKeyInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if v.KeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
	}
	if v.KeyType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpcLinkInput(v *CreateVpcLinkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcLinkInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TargetArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetArns"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteApiKeyInput(v *DeleteApiKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApiKeyInput"}
	if v.ApiKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAuthorizerInput(v *DeleteAuthorizerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAuthorizerInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.AuthorizerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteBasePathMappingInput(v *DeleteBasePathMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBasePathMappingInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.BasePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BasePath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteClientCertificateInput(v *DeleteClientCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteClientCertificateInput"}
	if v.ClientCertificateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientCertificateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDeploymentInput(v *DeleteDeploymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDeploymentInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DeploymentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDocumentationPartInput(v *DeleteDocumentationPartInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDocumentationPartInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DocumentationPartId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentationPartId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDocumentationVersionInput(v *DeleteDocumentationVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDocumentationVersionInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DocumentationVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentationVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDomainNameInput(v *DeleteDomainNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDomainNameInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteGatewayResponseInput(v *DeleteGatewayResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if len(v.ResponseType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResponseType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIntegrationInput(v *DeleteIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIntegrationResponseInput(v *DeleteIntegrationResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.StatusCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteMethodInput(v *DeleteMethodInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMethodInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteMethodResponseInput(v *DeleteMethodResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMethodResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.StatusCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteModelInput(v *DeleteModelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteModelInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRequestValidatorInput(v *DeleteRequestValidatorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRequestValidatorInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.RequestValidatorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestValidatorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteResourceInput(v *DeleteResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRestApiInput(v *DeleteRestApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRestApiInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteStageInput(v *DeleteStageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteStageInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUsagePlanInput(v *DeleteUsagePlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUsagePlanInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUsagePlanKeyInput(v *DeleteUsagePlanKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUsagePlanKeyInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if v.KeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpcLinkInput(v *DeleteVpcLinkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcLinkInput"}
	if v.VpcLinkId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpFlushStageAuthorizersCacheInput(v *FlushStageAuthorizersCacheInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlushStageAuthorizersCacheInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpFlushStageCacheInput(v *FlushStageCacheInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlushStageCacheInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetApiKeyInput(v *GetApiKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetApiKeyInput"}
	if v.ApiKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAuthorizerInput(v *GetAuthorizerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAuthorizerInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.AuthorizerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAuthorizersInput(v *GetAuthorizersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAuthorizersInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetBasePathMappingInput(v *GetBasePathMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetBasePathMappingInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.BasePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BasePath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetBasePathMappingsInput(v *GetBasePathMappingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetBasePathMappingsInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetClientCertificateInput(v *GetClientCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetClientCertificateInput"}
	if v.ClientCertificateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientCertificateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDeploymentInput(v *GetDeploymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DeploymentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDeploymentsInput(v *GetDeploymentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentsInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDocumentationPartInput(v *GetDocumentationPartInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDocumentationPartInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DocumentationPartId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentationPartId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDocumentationPartsInput(v *GetDocumentationPartsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDocumentationPartsInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDocumentationVersionInput(v *GetDocumentationVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDocumentationVersionInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DocumentationVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentationVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDocumentationVersionsInput(v *GetDocumentationVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDocumentationVersionsInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDomainNameInput(v *GetDomainNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDomainNameInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetExportInput(v *GetExportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetExportInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	if v.ExportType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGatewayResponseInput(v *GetGatewayResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGatewayResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if len(v.ResponseType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResponseType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGatewayResponsesInput(v *GetGatewayResponsesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGatewayResponsesInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIntegrationInput(v *GetIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIntegrationResponseInput(v *GetIntegrationResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.StatusCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMethodInput(v *GetMethodInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMethodInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMethodResponseInput(v *GetMethodResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMethodResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.StatusCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetModelInput(v *GetModelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetModelInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetModelsInput(v *GetModelsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetModelsInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetModelTemplateInput(v *GetModelTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetModelTemplateInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRequestValidatorInput(v *GetRequestValidatorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRequestValidatorInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.RequestValidatorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestValidatorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRequestValidatorsInput(v *GetRequestValidatorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRequestValidatorsInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResourceInput(v *GetResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourceInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResourcesInput(v *GetResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourcesInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRestApiInput(v *GetRestApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRestApiInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSdkInput(v *GetSdkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSdkInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	if v.SdkType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SdkType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSdkTypeInput(v *GetSdkTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSdkTypeInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStageInput(v *GetStageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStageInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStagesInput(v *GetStagesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStagesInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTagsInput(v *GetTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTagsInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUsageInput(v *GetUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUsageInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if v.StartDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
	}
	if v.EndDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUsagePlanInput(v *GetUsagePlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUsagePlanInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUsagePlanKeyInput(v *GetUsagePlanKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUsagePlanKeyInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if v.KeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUsagePlanKeysInput(v *GetUsagePlanKeysInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUsagePlanKeysInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVpcLinkInput(v *GetVpcLinkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVpcLinkInput"}
	if v.VpcLinkId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportApiKeysInput(v *ImportApiKeysInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportApiKeysInput"}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportDocumentationPartsInput(v *ImportDocumentationPartsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportDocumentationPartsInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportRestApiInput(v *ImportRestApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportRestApiInput"}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutGatewayResponseInput(v *PutGatewayResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutGatewayResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if len(v.ResponseType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResponseType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutIntegrationInput(v *PutIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutIntegrationInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutIntegrationResponseInput(v *PutIntegrationResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutIntegrationResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.StatusCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutMethodInput(v *PutMethodInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutMethodInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.AuthorizationType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutMethodResponseInput(v *PutMethodResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutMethodResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.StatusCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutRestApiInput(v *PutRestApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRestApiInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTestInvokeAuthorizerInput(v *TestInvokeAuthorizerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestInvokeAuthorizerInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.AuthorizerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTestInvokeMethodInput(v *TestInvokeMethodInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestInvokeMethodInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApiKeyInput(v *UpdateApiKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApiKeyInput"}
	if v.ApiKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAuthorizerInput(v *UpdateAuthorizerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAuthorizerInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.AuthorizerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBasePathMappingInput(v *UpdateBasePathMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBasePathMappingInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.BasePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BasePath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateClientCertificateInput(v *UpdateClientCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateClientCertificateInput"}
	if v.ClientCertificateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientCertificateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDeploymentInput(v *UpdateDeploymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDeploymentInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DeploymentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDocumentationPartInput(v *UpdateDocumentationPartInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDocumentationPartInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DocumentationPartId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentationPartId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDocumentationVersionInput(v *UpdateDocumentationVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDocumentationVersionInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.DocumentationVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentationVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDomainNameInput(v *UpdateDomainNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainNameInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGatewayResponseInput(v *UpdateGatewayResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if len(v.ResponseType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResponseType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIntegrationInput(v *UpdateIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntegrationInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIntegrationResponseInput(v *UpdateIntegrationResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntegrationResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.StatusCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMethodInput(v *UpdateMethodInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMethodInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMethodResponseInput(v *UpdateMethodResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMethodResponseInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.HttpMethod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
	}
	if v.StatusCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateModelInput(v *UpdateModelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateModelInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRequestValidatorInput(v *UpdateRequestValidatorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRequestValidatorInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.RequestValidatorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestValidatorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateResourceInput(v *UpdateResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRestApiInput(v *UpdateRestApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRestApiInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateStageInput(v *UpdateStageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStageInput"}
	if v.RestApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUsageInput(v *UpdateUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUsageInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if v.KeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUsagePlanInput(v *UpdateUsagePlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUsagePlanInput"}
	if v.UsagePlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateVpcLinkInput(v *UpdateVpcLinkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVpcLinkInput"}
	if v.VpcLinkId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}