validators.go

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

package apigatewayv2

import (
	"context"
	"fmt"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpCreateApi struct {
}

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

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

type validateOpCreateApiMapping struct {
}

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

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

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 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 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 validateOpCreateIntegration struct {
}

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

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

type validateOpCreateIntegrationResponse struct {
}

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

func (m *validateOpCreateIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateIntegrationResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateIntegrationResponseInput(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 validateOpCreateRoute struct {
}

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

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

type validateOpCreateRouteResponse struct {
}

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

func (m *validateOpCreateRouteResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRouteResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRouteResponseInput(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 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 validateOpDeleteAccessLogSettings struct {
}

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

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

type validateOpDeleteApi struct {
}

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

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

type validateOpDeleteApiMapping struct {
}

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

func (m *validateOpDeleteApiMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteApiMappingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteApiMappingInput(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 validateOpDeleteCorsConfiguration struct {
}

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

func (m *validateOpDeleteCorsConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteCorsConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteCorsConfigurationInput(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 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 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 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 validateOpDeleteRoute struct {
}

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

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

type validateOpDeleteRouteRequestParameter struct {
}

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

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

type validateOpDeleteRouteResponse struct {
}

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

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

type validateOpDeleteRouteSettings struct {
}

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

func (m *validateOpDeleteRouteSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRouteSettingsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRouteSettingsInput(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 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 validateOpExportApi struct {
}

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

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

type validateOpGetApi struct {
}

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

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

type validateOpGetApiMapping struct {
}

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

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

type validateOpGetApiMappings struct {
}

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

func (m *validateOpGetApiMappings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetApiMappingsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetApiMappingsInput(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 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 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 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 validateOpGetIntegrationResponses struct {
}

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

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

type validateOpGetIntegrations struct {
}

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

func (m *validateOpGetIntegrations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIntegrationsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIntegrationsInput(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 validateOpGetRoute struct {
}

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

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

type validateOpGetRouteResponse struct {
}

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

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

type validateOpGetRouteResponses struct {
}

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

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

type validateOpGetRoutes struct {
}

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

func (m *validateOpGetRoutes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRoutesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRoutesInput(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 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 validateOpImportApi struct {
}

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

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

type validateOpReimportApi struct {
}

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

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

type validateOpResetAuthorizersCache struct {
}

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

func (m *validateOpResetAuthorizersCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ResetAuthorizersCacheInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpResetAuthorizersCacheInput(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 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 validateOpUpdateApi struct {
}

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

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

type validateOpUpdateApiMapping struct {
}

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

func (m *validateOpUpdateApiMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateApiMappingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateApiMappingInput(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 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 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 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 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 validateOpUpdateRoute struct {
}

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

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

type validateOpUpdateRouteResponse struct {
}

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

func (m *validateOpUpdateRouteResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRouteResponseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRouteResponseInput(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 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 addOpCreateApiValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateApi{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpDeleteDomainNameValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDomainName{}, 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 addOpDeleteModelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteModel{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

func addOpGetApiMappingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetApiMappings{}, 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 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 addOpGetDomainNameValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDomainName{}, 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 addOpGetIntegrationResponsesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIntegrationResponses{}, middleware.After)
}

func addOpGetIntegrationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIntegrations{}, 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 addOpGetRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRoute{}, middleware.After)
}

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

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

func addOpGetRoutesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRoutes{}, 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 addOpGetVpcLinkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVpcLink{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

func addOpUpdateDomainNameValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDomainName{}, 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 addOpUpdateModelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateModel{}, middleware.After)
}

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

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

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

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

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

func validateOpCreateApiMappingInput(v *CreateApiMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateApiMappingInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.Stage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Stage"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if len(v.AuthorizerType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerType"))
	}
	if v.IdentitySource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentitySource"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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 validateOpCreateIntegrationInput(v *CreateIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIntegrationInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if len(v.IntegrationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIntegrationResponseInput(v *CreateIntegrationResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIntegrationResponseInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.IntegrationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
	}
	if v.IntegrationResponseKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResponseKey"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Schema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schema"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRouteInput(v *CreateRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRouteResponseInput(v *CreateRouteResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteResponseInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if v.RouteResponseKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteResponseKey"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	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.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteApiMappingInput(v *DeleteApiMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApiMappingInput"}
	if v.ApiMappingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiMappingId"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.AuthorizerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCorsConfigurationInput(v *DeleteCorsConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCorsConfigurationInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.DeploymentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
	}
	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 validateOpDeleteIntegrationInput(v *DeleteIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.IntegrationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.IntegrationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
	}
	if v.IntegrationResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResponseId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRouteInput(v *DeleteRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRouteRequestParameterInput(v *DeleteRouteRequestParameterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteRequestParameterInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RequestParameterKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestParameterKey"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRouteResponseInput(v *DeleteRouteResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteResponseInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if v.RouteResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteResponseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRouteSettingsInput(v *DeleteRouteSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteSettingsInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteKey"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	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 validateOpExportApiInput(v *ExportApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportApiInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.OutputType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputType"))
	}
	if v.Specification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Specification"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetApiMappingsInput(v *GetApiMappingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetApiMappingsInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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 validateOpGetIntegrationInput(v *GetIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.IntegrationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.IntegrationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
	}
	if v.IntegrationResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResponseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIntegrationResponsesInput(v *GetIntegrationResponsesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationResponsesInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.IntegrationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIntegrationsInput(v *GetIntegrationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationsInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRouteInput(v *GetRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRouteInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRouteResponseInput(v *GetRouteResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRouteResponseInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if v.RouteResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteResponseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRouteResponsesInput(v *GetRouteResponsesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRouteResponsesInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRoutesInput(v *GetRoutesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRoutesInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	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 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 validateOpImportApiInput(v *ImportApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportApiInput"}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpResetAuthorizersCacheInput(v *ResetAuthorizersCacheInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetAuthorizersCacheInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	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 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 validateOpUpdateApiInput(v *UpdateApiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApiInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApiMappingInput(v *UpdateApiMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApiMappingInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.ApiMappingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiMappingId"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.AuthorizerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.DeploymentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
	}
	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 validateOpUpdateIntegrationInput(v *UpdateIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntegrationInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.IntegrationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.IntegrationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
	}
	if v.IntegrationResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResponseId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRouteInput(v *UpdateRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRouteInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRouteResponseInput(v *UpdateRouteResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRouteResponseInput"}
	if v.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.RouteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
	}
	if v.RouteResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteResponseId"))
	}
	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.ApiId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
	}
	if v.StageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
	}
	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
	}
}