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

package support

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

type validateOpAddAttachmentsToSet struct {
}

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

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

type validateOpAddCommunicationToCase struct {
}

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

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

type validateOpCreateCase struct {
}

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

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

type validateOpDescribeAttachment struct {
}

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

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

type validateOpDescribeCommunications struct {
}

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

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

type validateOpDescribeCreateCaseOptions struct {
}

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

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

type validateOpDescribeSupportedLanguages struct {
}

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

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

type validateOpDescribeTrustedAdvisorCheckRefreshStatuses struct {
}

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

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

type validateOpDescribeTrustedAdvisorCheckResult struct {
}

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

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

type validateOpDescribeTrustedAdvisorChecks struct {
}

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

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

type validateOpDescribeTrustedAdvisorCheckSummaries struct {
}

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

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

type validateOpRefreshTrustedAdvisorCheck struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpCreateCaseInput(v *CreateCaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCaseInput"}
	if v.Subject == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
	}
	if v.CommunicationBody == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommunicationBody"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeCreateCaseOptionsInput(v *DescribeCreateCaseOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeCreateCaseOptionsInput"}
	if v.IssueType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IssueType"))
	}
	if v.ServiceCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceCode"))
	}
	if v.Language == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Language"))
	}
	if v.CategoryCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CategoryCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeSupportedLanguagesInput(v *DescribeSupportedLanguagesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSupportedLanguagesInput"}
	if v.IssueType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IssueType"))
	}
	if v.ServiceCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceCode"))
	}
	if v.CategoryCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CategoryCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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