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

package alexaforbusiness

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

type validateOpApproveSkill struct {
}

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

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

type validateOpAssociateContactWithAddressBook struct {
}

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

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

type validateOpAssociateDeviceWithNetworkProfile struct {
}

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

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

type validateOpAssociateSkillWithSkillGroup struct {
}

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

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

type validateOpAssociateSkillWithUsers struct {
}

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

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

type validateOpCreateAddressBook struct {
}

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

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

type validateOpCreateBusinessReportSchedule struct {
}

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

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

type validateOpCreateConferenceProvider struct {
}

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

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

type validateOpCreateContact struct {
}

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

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

type validateOpCreateGatewayGroup struct {
}

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

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

type validateOpCreateNetworkProfile struct {
}

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

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

type validateOpCreateProfile struct {
}

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

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

type validateOpCreateRoom struct {
}

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

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

type validateOpCreateSkillGroup struct {
}

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

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

type validateOpCreateUser struct {
}

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

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

type validateOpDeleteAddressBook struct {
}

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

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

type validateOpDeleteBusinessReportSchedule struct {
}

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

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

type validateOpDeleteConferenceProvider struct {
}

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

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

type validateOpDeleteContact struct {
}

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

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

type validateOpDeleteDevice struct {
}

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

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

type validateOpDeleteDeviceUsageData struct {
}

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

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

type validateOpDeleteGatewayGroup struct {
}

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

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

type validateOpDeleteNetworkProfile struct {
}

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

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

type validateOpDeleteRoomSkillParameter struct {
}

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

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

type validateOpDeleteSkillAuthorization struct {
}

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

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

type validateOpDeleteUser struct {
}

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

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

type validateOpDisassociateContactFromAddressBook struct {
}

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

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

type validateOpDisassociateSkillFromSkillGroup struct {
}

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

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

type validateOpDisassociateSkillFromUsers struct {
}

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

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

type validateOpForgetSmartHomeAppliances struct {
}

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

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

type validateOpGetAddressBook struct {
}

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

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

type validateOpGetConferenceProvider struct {
}

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

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

type validateOpGetContact struct {
}

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

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

type validateOpGetGatewayGroup struct {
}

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

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

type validateOpGetGateway struct {
}

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

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

type validateOpGetNetworkProfile struct {
}

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

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

type validateOpGetRoomSkillParameter struct {
}

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

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

type validateOpListDeviceEvents struct {
}

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

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

type validateOpListSkillsStoreSkillsByCategory struct {
}

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

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

type validateOpListSmartHomeAppliances struct {
}

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

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

type validateOpListTags struct {
}

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

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

type validateOpPutConferencePreference struct {
}

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

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

type validateOpPutInvitationConfiguration struct {
}

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

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

type validateOpPutRoomSkillParameter struct {
}

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

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

type validateOpPutSkillAuthorization struct {
}

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

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

type validateOpRegisterAVSDevice struct {
}

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

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

type validateOpRejectSkill struct {
}

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

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

type validateOpResolveRoom struct {
}

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

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

type validateOpSearchAddressBooks struct {
}

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

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

type validateOpSearchContacts struct {
}

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

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

type validateOpSearchDevices struct {
}

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

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

type validateOpSearchNetworkProfiles struct {
}

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

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

type validateOpSearchProfiles struct {
}

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

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

type validateOpSearchRooms struct {
}

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

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

type validateOpSearchSkillGroups struct {
}

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

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

type validateOpSearchUsers struct {
}

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

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

type validateOpSendAnnouncement struct {
}

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

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

type validateOpStartDeviceSync struct {
}

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

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

type validateOpStartSmartHomeApplianceDiscovery struct {
}

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

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

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

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

type validateOpUpdateBusinessReportSchedule struct {
}

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

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

type validateOpUpdateConferenceProvider struct {
}

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

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

type validateOpUpdateContact struct {
}

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

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

type validateOpUpdateGatewayGroup struct {
}

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

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

type validateOpUpdateGateway struct {
}

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

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

type validateOpUpdateNetworkProfile struct {
}

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

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

type validateOpUpdateProfile struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStartSmartHomeApplianceDiscoveryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartSmartHomeApplianceDiscovery{}, 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 addOpUpdateAddressBookValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAddressBook{}, middleware.After)
}

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

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

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

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

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

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

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

func validateAudio(v *types.Audio) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Audio"}
	if len(v.Locale) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Locale"))
	}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioList(v []types.Audio) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioList"}
	for i := range v {
		if err := validateAudio(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateContent(v *types.Content) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Content"}
	if v.TextList != nil {
		if err := validateTextList(v.TextList); err != nil {
			invalidParams.AddNested("TextList", err.(smithy.InvalidParamsError))
		}
	}
	if v.SsmlList != nil {
		if err := validateSsmlList(v.SsmlList); err != nil {
			invalidParams.AddNested("SsmlList", err.(smithy.InvalidParamsError))
		}
	}
	if v.AudioList != nil {
		if err := validateAudioList(v.AudioList); err != nil {
			invalidParams.AddNested("AudioList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateEndOfMeetingReminder(v *types.CreateEndOfMeetingReminder) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEndOfMeetingReminder"}
	if v.ReminderAtMinutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReminderAtMinutes"))
	}
	if len(v.ReminderType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ReminderType"))
	}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateInstantBooking(v *types.CreateInstantBooking) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstantBooking"}
	if v.DurationInMinutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DurationInMinutes"))
	}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateMeetingRoomConfiguration(v *types.CreateMeetingRoomConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMeetingRoomConfiguration"}
	if v.EndOfMeetingReminder != nil {
		if err := validateCreateEndOfMeetingReminder(v.EndOfMeetingReminder); err != nil {
			invalidParams.AddNested("EndOfMeetingReminder", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstantBooking != nil {
		if err := validateCreateInstantBooking(v.InstantBooking); err != nil {
			invalidParams.AddNested("InstantBooking", err.(smithy.InvalidParamsError))
		}
	}
	if v.RequireCheckIn != nil {
		if err := validateCreateRequireCheckIn(v.RequireCheckIn); err != nil {
			invalidParams.AddNested("RequireCheckIn", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProactiveJoin != nil {
		if err := validateCreateProactiveJoin(v.ProactiveJoin); err != nil {
			invalidParams.AddNested("ProactiveJoin", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateProactiveJoin(v *types.CreateProactiveJoin) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProactiveJoin"}
	if v.EnabledByMotion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnabledByMotion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateRequireCheckIn(v *types.CreateRequireCheckIn) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRequireCheckIn"}
	if v.ReleaseAfterMinutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReleaseAfterMinutes"))
	}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilter(v *types.Filter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Filter"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterList(v []types.Filter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterList"}
	for i := range v {
		if err := validateFilter(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIPDialIn(v *types.IPDialIn) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IPDialIn"}
	if v.Endpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Endpoint"))
	}
	if len(v.CommsProtocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CommsProtocol"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePhoneNumberList(v []types.PhoneNumber) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PhoneNumberList"}
	for i := range v {
		if err := validatePhoneNumber(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePSTNDialIn(v *types.PSTNDialIn) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PSTNDialIn"}
	if v.CountryCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CountryCode"))
	}
	if v.PhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhoneNumber"))
	}
	if v.OneClickIdDelay == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OneClickIdDelay"))
	}
	if v.OneClickPinDelay == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OneClickPinDelay"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRoomSkillParameter(v *types.RoomSkillParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RoomSkillParameter"}
	if v.ParameterKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterKey"))
	}
	if v.ParameterValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSipAddressList(v []types.SipAddress) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SipAddressList"}
	for i := range v {
		if err := validateSipAddress(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSort(v *types.Sort) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Sort"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if len(v.Value) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSortList(v []types.Sort) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SortList"}
	for i := range v {
		if err := validateSort(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSsml(v *types.Ssml) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Ssml"}
	if len(v.Locale) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Locale"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSsmlList(v []types.Ssml) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SsmlList"}
	for i := range v {
		if err := validateSsml(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTag(v *types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	for i := range v {
		if err := validateTag(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateText(v *types.Text) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Text"}
	if len(v.Locale) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Locale"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTextList(v []types.Text) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TextList"}
	for i := range v {
		if err := validateText(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateMeetingRoomConfiguration(v *types.UpdateMeetingRoomConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMeetingRoomConfiguration"}
	if v.ProactiveJoin != nil {
		if err := validateUpdateProactiveJoin(v.ProactiveJoin); err != nil {
			invalidParams.AddNested("ProactiveJoin", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateProactiveJoin(v *types.UpdateProactiveJoin) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProactiveJoin"}
	if v.EnabledByMotion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnabledByMotion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateContactWithAddressBookInput(v *AssociateContactWithAddressBookInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateContactWithAddressBookInput"}
	if v.ContactArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactArn"))
	}
	if v.AddressBookArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AddressBookArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateDeviceWithNetworkProfileInput(v *AssociateDeviceWithNetworkProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateDeviceWithNetworkProfileInput"}
	if v.DeviceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceArn"))
	}
	if v.NetworkProfileArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkProfileArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateAddressBookInput(v *CreateAddressBookInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAddressBookInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBusinessReportScheduleInput(v *CreateBusinessReportScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBusinessReportScheduleInput"}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if v.ContentRange == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentRange"))
	} else if v.ContentRange != nil {
		if err := validateBusinessReportContentRange(v.ContentRange); err != nil {
			invalidParams.AddNested("ContentRange", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConferenceProviderInput(v *CreateConferenceProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConferenceProviderInput"}
	if v.ConferenceProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConferenceProviderName"))
	}
	if len(v.ConferenceProviderType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ConferenceProviderType"))
	}
	if v.IPDialIn != nil {
		if err := validateIPDialIn(v.IPDialIn); err != nil {
			invalidParams.AddNested("IPDialIn", err.(smithy.InvalidParamsError))
		}
	}
	if v.PSTNDialIn != nil {
		if err := validatePSTNDialIn(v.PSTNDialIn); err != nil {
			invalidParams.AddNested("PSTNDialIn", err.(smithy.InvalidParamsError))
		}
	}
	if v.MeetingSetting == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingSetting"))
	} else if v.MeetingSetting != nil {
		if err := validateMeetingSetting(v.MeetingSetting); err != nil {
			invalidParams.AddNested("MeetingSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContactInput(v *CreateContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContactInput"}
	if v.FirstName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirstName"))
	}
	if v.PhoneNumbers != nil {
		if err := validatePhoneNumberList(v.PhoneNumbers); err != nil {
			invalidParams.AddNested("PhoneNumbers", err.(smithy.InvalidParamsError))
		}
	}
	if v.SipAddresses != nil {
		if err := validateSipAddressList(v.SipAddresses); err != nil {
			invalidParams.AddNested("SipAddresses", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGatewayGroupInput(v *CreateGatewayGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGatewayGroupInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNetworkProfileInput(v *CreateNetworkProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkProfileInput"}
	if v.NetworkProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkProfileName"))
	}
	if v.Ssid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ssid"))
	}
	if len(v.SecurityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityType"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateProfileInput(v *CreateProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProfileInput"}
	if v.ProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileName"))
	}
	if v.Timezone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Timezone"))
	}
	if v.Address == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Address"))
	}
	if len(v.DistanceUnit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DistanceUnit"))
	}
	if len(v.TemperatureUnit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TemperatureUnit"))
	}
	if len(v.WakeWord) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("WakeWord"))
	}
	if v.MeetingRoomConfiguration != nil {
		if err := validateCreateMeetingRoomConfiguration(v.MeetingRoomConfiguration); err != nil {
			invalidParams.AddNested("MeetingRoomConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRoomInput(v *CreateRoomInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRoomInput"}
	if v.RoomName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSkillGroupInput(v *CreateSkillGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSkillGroupInput"}
	if v.SkillGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SkillGroupName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserInput(v *CreateUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserInput"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDeleteDeviceUsageDataInput(v *DeleteDeviceUsageDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDeviceUsageDataInput"}
	if v.DeviceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceArn"))
	}
	if len(v.DeviceUsageType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceUsageType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteRoomSkillParameterInput(v *DeleteRoomSkillParameterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRoomSkillParameterInput"}
	if v.SkillId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SkillId"))
	}
	if v.ParameterKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDisassociateContactFromAddressBookInput(v *DisassociateContactFromAddressBookInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateContactFromAddressBookInput"}
	if v.ContactArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactArn"))
	}
	if v.AddressBookArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AddressBookArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpGetRoomSkillParameterInput(v *GetRoomSkillParameterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRoomSkillParameterInput"}
	if v.SkillId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SkillId"))
	}
	if v.ParameterKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpPutRoomSkillParameterInput(v *PutRoomSkillParameterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRoomSkillParameterInput"}
	if v.SkillId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SkillId"))
	}
	if v.RoomSkillParameter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomSkillParameter"))
	} else if v.RoomSkillParameter != nil {
		if err := validateRoomSkillParameter(v.RoomSkillParameter); err != nil {
			invalidParams.AddNested("RoomSkillParameter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutSkillAuthorizationInput(v *PutSkillAuthorizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutSkillAuthorizationInput"}
	if v.AuthorizationResult == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationResult"))
	}
	if v.SkillId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SkillId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterAVSDeviceInput(v *RegisterAVSDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterAVSDeviceInput"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.UserCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserCode"))
	}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.AmazonId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AmazonId"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpResolveRoomInput(v *ResolveRoomInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResolveRoomInput"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.SkillId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SkillId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchAddressBooksInput(v *SearchAddressBooksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchAddressBooksInput"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortCriteria != nil {
		if err := validateSortList(v.SortCriteria); err != nil {
			invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchContactsInput(v *SearchContactsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchContactsInput"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortCriteria != nil {
		if err := validateSortList(v.SortCriteria); err != nil {
			invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchDevicesInput(v *SearchDevicesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchDevicesInput"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortCriteria != nil {
		if err := validateSortList(v.SortCriteria); err != nil {
			invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchNetworkProfilesInput(v *SearchNetworkProfilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchNetworkProfilesInput"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortCriteria != nil {
		if err := validateSortList(v.SortCriteria); err != nil {
			invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchProfilesInput(v *SearchProfilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchProfilesInput"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortCriteria != nil {
		if err := validateSortList(v.SortCriteria); err != nil {
			invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchRoomsInput(v *SearchRoomsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchRoomsInput"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortCriteria != nil {
		if err := validateSortList(v.SortCriteria); err != nil {
			invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchSkillGroupsInput(v *SearchSkillGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchSkillGroupsInput"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortCriteria != nil {
		if err := validateSortList(v.SortCriteria); err != nil {
			invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchUsersInput(v *SearchUsersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchUsersInput"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortCriteria != nil {
		if err := validateSortList(v.SortCriteria); err != nil {
			invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendAnnouncementInput(v *SendAnnouncementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendAnnouncementInput"}
	if v.RoomFilters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomFilters"))
	} else if v.RoomFilters != nil {
		if err := validateFilterList(v.RoomFilters); err != nil {
			invalidParams.AddNested("RoomFilters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartSmartHomeApplianceDiscoveryInput(v *StartSmartHomeApplianceDiscoveryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartSmartHomeApplianceDiscoveryInput"}
	if v.RoomArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomArn"))
	}
	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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateConferenceProviderInput(v *UpdateConferenceProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConferenceProviderInput"}
	if v.ConferenceProviderArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConferenceProviderArn"))
	}
	if len(v.ConferenceProviderType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ConferenceProviderType"))
	}
	if v.IPDialIn != nil {
		if err := validateIPDialIn(v.IPDialIn); err != nil {
			invalidParams.AddNested("IPDialIn", err.(smithy.InvalidParamsError))
		}
	}
	if v.PSTNDialIn != nil {
		if err := validatePSTNDialIn(v.PSTNDialIn); err != nil {
			invalidParams.AddNested("PSTNDialIn", err.(smithy.InvalidParamsError))
		}
	}
	if v.MeetingSetting == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingSetting"))
	} else if v.MeetingSetting != nil {
		if err := validateMeetingSetting(v.MeetingSetting); err != nil {
			invalidParams.AddNested("MeetingSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactInput(v *UpdateContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactInput"}
	if v.ContactArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactArn"))
	}
	if v.PhoneNumbers != nil {
		if err := validatePhoneNumberList(v.PhoneNumbers); err != nil {
			invalidParams.AddNested("PhoneNumbers", err.(smithy.InvalidParamsError))
		}
	}
	if v.SipAddresses != nil {
		if err := validateSipAddressList(v.SipAddresses); err != nil {
			invalidParams.AddNested("SipAddresses", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateProfileInput(v *UpdateProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProfileInput"}
	if v.MeetingRoomConfiguration != nil {
		if err := validateUpdateMeetingRoomConfiguration(v.MeetingRoomConfiguration); err != nil {
			invalidParams.AddNested("MeetingRoomConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}