validators.go

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

package supportapp

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

type validateOpCreateSlackChannelConfiguration struct {
}

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

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

type validateOpDeleteSlackChannelConfiguration struct {
}

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

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

type validateOpDeleteSlackWorkspaceConfiguration struct {
}

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

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

type validateOpPutAccountAlias struct {
}

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

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

type validateOpRegisterSlackWorkspaceForOrganization struct {
}

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

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

type validateOpUpdateSlackChannelConfiguration struct {
}

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

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

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

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

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

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

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

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

func validateOpCreateSlackChannelConfigurationInput(v *CreateSlackChannelConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSlackChannelConfigurationInput"}
	if v.TeamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TeamId"))
	}
	if v.ChannelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelId"))
	}
	if len(v.NotifyOnCaseSeverity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NotifyOnCaseSeverity"))
	}
	if v.ChannelRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSlackChannelConfigurationInput(v *DeleteSlackChannelConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSlackChannelConfigurationInput"}
	if v.TeamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TeamId"))
	}
	if v.ChannelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateSlackChannelConfigurationInput(v *UpdateSlackChannelConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSlackChannelConfigurationInput"}
	if v.TeamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TeamId"))
	}
	if v.ChannelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}