service/pcaconnectorad/validators.go

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

package pcaconnectorad

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

type validateOpCreateConnector struct {
}

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

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

type validateOpCreateDirectoryRegistration struct {
}

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

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

type validateOpCreateServicePrincipalName struct {
}

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

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

type validateOpCreateTemplateGroupAccessControlEntry struct {
}

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

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

type validateOpCreateTemplate struct {
}

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

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

type validateOpDeleteConnector struct {
}

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

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

type validateOpDeleteDirectoryRegistration struct {
}

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

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

type validateOpDeleteServicePrincipalName struct {
}

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

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

type validateOpDeleteTemplateGroupAccessControlEntry struct {
}

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

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

type validateOpDeleteTemplate struct {
}

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

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

type validateOpGetConnector struct {
}

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

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

type validateOpGetDirectoryRegistration struct {
}

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

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

type validateOpGetServicePrincipalName struct {
}

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

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

type validateOpGetTemplateGroupAccessControlEntry struct {
}

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

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

type validateOpGetTemplate struct {
}

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

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

type validateOpListServicePrincipalNames struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpListTemplateGroupAccessControlEntries struct {
}

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

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

type validateOpListTemplates struct {
}

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

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

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

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

type validateOpUpdateTemplate struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpListTemplatesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTemplates{}, 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 addOpUpdateTemplateGroupAccessControlEntryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateTemplateGroupAccessControlEntry{}, middleware.After)
}

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

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

func validateCertificateValidity(v *types.CertificateValidity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CertificateValidity"}
	if v.ValidityPeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValidityPeriod"))
	} else if v.ValidityPeriod != nil {
		if err := validateValidityPeriod(v.ValidityPeriod); err != nil {
			invalidParams.AddNested("ValidityPeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.RenewalPeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RenewalPeriod"))
	} else if v.RenewalPeriod != nil {
		if err := validateValidityPeriod(v.RenewalPeriod); err != nil {
			invalidParams.AddNested("RenewalPeriod", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExtensionsV2(v *types.ExtensionsV2) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExtensionsV2"}
	if v.KeyUsage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyUsage"))
	} else if v.KeyUsage != nil {
		if err := validateKeyUsage(v.KeyUsage); err != nil {
			invalidParams.AddNested("KeyUsage", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplicationPolicies != nil {
		if err := validateApplicationPolicies(v.ApplicationPolicies); err != nil {
			invalidParams.AddNested("ApplicationPolicies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExtensionsV3(v *types.ExtensionsV3) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExtensionsV3"}
	if v.KeyUsage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyUsage"))
	} else if v.KeyUsage != nil {
		if err := validateKeyUsage(v.KeyUsage); err != nil {
			invalidParams.AddNested("KeyUsage", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplicationPolicies != nil {
		if err := validateApplicationPolicies(v.ApplicationPolicies); err != nil {
			invalidParams.AddNested("ApplicationPolicies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExtensionsV4(v *types.ExtensionsV4) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExtensionsV4"}
	if v.KeyUsage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyUsage"))
	} else if v.KeyUsage != nil {
		if err := validateKeyUsage(v.KeyUsage); err != nil {
			invalidParams.AddNested("KeyUsage", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplicationPolicies != nil {
		if err := validateApplicationPolicies(v.ApplicationPolicies); err != nil {
			invalidParams.AddNested("ApplicationPolicies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePrivateKeyAttributesV2(v *types.PrivateKeyAttributesV2) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrivateKeyAttributesV2"}
	if v.MinimalKeyLength == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinimalKeyLength"))
	}
	if len(v.KeySpec) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("KeySpec"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePrivateKeyAttributesV3(v *types.PrivateKeyAttributesV3) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrivateKeyAttributesV3"}
	if v.MinimalKeyLength == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinimalKeyLength"))
	}
	if len(v.KeySpec) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("KeySpec"))
	}
	if v.KeyUsageProperty == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyUsageProperty"))
	}
	if len(v.Algorithm) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Algorithm"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePrivateKeyAttributesV4(v *types.PrivateKeyAttributesV4) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrivateKeyAttributesV4"}
	if v.MinimalKeyLength == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinimalKeyLength"))
	}
	if len(v.KeySpec) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("KeySpec"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateTemplateDefinition(v types.TemplateDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateDefinition"}
	switch uv := v.(type) {
	case *types.TemplateDefinitionMemberTemplateV2:
		if err := validateTemplateV2(&uv.Value); err != nil {
			invalidParams.AddNested("[TemplateV2]", err.(smithy.InvalidParamsError))
		}

	case *types.TemplateDefinitionMemberTemplateV3:
		if err := validateTemplateV3(&uv.Value); err != nil {
			invalidParams.AddNested("[TemplateV3]", err.(smithy.InvalidParamsError))
		}

	case *types.TemplateDefinitionMemberTemplateV4:
		if err := validateTemplateV4(&uv.Value); err != nil {
			invalidParams.AddNested("[TemplateV4]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTemplateV2(v *types.TemplateV2) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateV2"}
	if v.CertificateValidity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateValidity"))
	} else if v.CertificateValidity != nil {
		if err := validateCertificateValidity(v.CertificateValidity); err != nil {
			invalidParams.AddNested("CertificateValidity", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrivateKeyAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivateKeyAttributes"))
	} else if v.PrivateKeyAttributes != nil {
		if err := validatePrivateKeyAttributesV2(v.PrivateKeyAttributes); err != nil {
			invalidParams.AddNested("PrivateKeyAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrivateKeyFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivateKeyFlags"))
	} else if v.PrivateKeyFlags != nil {
		if err := validatePrivateKeyFlagsV2(v.PrivateKeyFlags); err != nil {
			invalidParams.AddNested("PrivateKeyFlags", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnrollmentFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnrollmentFlags"))
	}
	if v.SubjectNameFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubjectNameFlags"))
	}
	if v.GeneralFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeneralFlags"))
	}
	if v.Extensions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Extensions"))
	} else if v.Extensions != nil {
		if err := validateExtensionsV2(v.Extensions); err != nil {
			invalidParams.AddNested("Extensions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTemplateV3(v *types.TemplateV3) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateV3"}
	if v.CertificateValidity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateValidity"))
	} else if v.CertificateValidity != nil {
		if err := validateCertificateValidity(v.CertificateValidity); err != nil {
			invalidParams.AddNested("CertificateValidity", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrivateKeyAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivateKeyAttributes"))
	} else if v.PrivateKeyAttributes != nil {
		if err := validatePrivateKeyAttributesV3(v.PrivateKeyAttributes); err != nil {
			invalidParams.AddNested("PrivateKeyAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrivateKeyFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivateKeyFlags"))
	} else if v.PrivateKeyFlags != nil {
		if err := validatePrivateKeyFlagsV3(v.PrivateKeyFlags); err != nil {
			invalidParams.AddNested("PrivateKeyFlags", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnrollmentFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnrollmentFlags"))
	}
	if v.SubjectNameFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubjectNameFlags"))
	}
	if v.GeneralFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeneralFlags"))
	}
	if len(v.HashAlgorithm) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("HashAlgorithm"))
	}
	if v.Extensions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Extensions"))
	} else if v.Extensions != nil {
		if err := validateExtensionsV3(v.Extensions); err != nil {
			invalidParams.AddNested("Extensions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTemplateV4(v *types.TemplateV4) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateV4"}
	if v.CertificateValidity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateValidity"))
	} else if v.CertificateValidity != nil {
		if err := validateCertificateValidity(v.CertificateValidity); err != nil {
			invalidParams.AddNested("CertificateValidity", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrivateKeyAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivateKeyAttributes"))
	} else if v.PrivateKeyAttributes != nil {
		if err := validatePrivateKeyAttributesV4(v.PrivateKeyAttributes); err != nil {
			invalidParams.AddNested("PrivateKeyAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrivateKeyFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivateKeyFlags"))
	} else if v.PrivateKeyFlags != nil {
		if err := validatePrivateKeyFlagsV4(v.PrivateKeyFlags); err != nil {
			invalidParams.AddNested("PrivateKeyFlags", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnrollmentFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnrollmentFlags"))
	}
	if v.SubjectNameFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubjectNameFlags"))
	}
	if v.GeneralFlags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeneralFlags"))
	}
	if v.Extensions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Extensions"))
	} else if v.Extensions != nil {
		if err := validateExtensionsV4(v.Extensions); err != nil {
			invalidParams.AddNested("Extensions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateValidityPeriod(v *types.ValidityPeriod) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ValidityPeriod"}
	if len(v.PeriodType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PeriodType"))
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateConnectorInput(v *CreateConnectorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectorInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.CertificateAuthorityArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
	}
	if v.VpcInformation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcInformation"))
	} else if v.VpcInformation != nil {
		if err := validateVpcInformation(v.VpcInformation); err != nil {
			invalidParams.AddNested("VpcInformation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateServicePrincipalNameInput(v *CreateServicePrincipalNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateServicePrincipalNameInput"}
	if v.DirectoryRegistrationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryRegistrationArn"))
	}
	if v.ConnectorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTemplateGroupAccessControlEntryInput(v *CreateTemplateGroupAccessControlEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateGroupAccessControlEntryInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.GroupSecurityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupSecurityIdentifier"))
	}
	if v.GroupDisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupDisplayName"))
	}
	if v.AccessRights == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessRights"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTemplateInput(v *CreateTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateInput"}
	if v.ConnectorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Definition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
	} else if v.Definition != nil {
		if err := validateTemplateDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteServicePrincipalNameInput(v *DeleteServicePrincipalNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteServicePrincipalNameInput"}
	if v.DirectoryRegistrationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryRegistrationArn"))
	}
	if v.ConnectorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTemplateGroupAccessControlEntryInput(v *DeleteTemplateGroupAccessControlEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTemplateGroupAccessControlEntryInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.GroupSecurityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupSecurityIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpGetServicePrincipalNameInput(v *GetServicePrincipalNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetServicePrincipalNameInput"}
	if v.DirectoryRegistrationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryRegistrationArn"))
	}
	if v.ConnectorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTemplateGroupAccessControlEntryInput(v *GetTemplateGroupAccessControlEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTemplateGroupAccessControlEntryInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.GroupSecurityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupSecurityIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpUpdateTemplateGroupAccessControlEntryInput(v *UpdateTemplateGroupAccessControlEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateGroupAccessControlEntryInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.GroupSecurityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupSecurityIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTemplateInput(v *UpdateTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.Definition != nil {
		if err := validateTemplateDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}