validators.go

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

package codecommit

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

type validateOpAssociateApprovalRuleTemplateWithRepository struct {
}

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

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

type validateOpBatchAssociateApprovalRuleTemplateWithRepositories struct {
}

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

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

type validateOpBatchDescribeMergeConflicts struct {
}

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

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

type validateOpBatchDisassociateApprovalRuleTemplateFromRepositories struct {
}

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

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

type validateOpBatchGetCommits struct {
}

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

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

type validateOpBatchGetRepositories struct {
}

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

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

type validateOpCreateApprovalRuleTemplate struct {
}

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

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

type validateOpCreateBranch struct {
}

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

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

type validateOpCreateCommit struct {
}

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

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

type validateOpCreatePullRequestApprovalRule struct {
}

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

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

type validateOpCreatePullRequest struct {
}

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

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

type validateOpCreateRepository struct {
}

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

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

type validateOpCreateUnreferencedMergeCommit struct {
}

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

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

type validateOpDeleteApprovalRuleTemplate struct {
}

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

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

type validateOpDeleteBranch struct {
}

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

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

type validateOpDeleteCommentContent struct {
}

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

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

type validateOpDeleteFile struct {
}

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

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

type validateOpDeletePullRequestApprovalRule struct {
}

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

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

type validateOpDeleteRepository struct {
}

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

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

type validateOpDescribeMergeConflicts struct {
}

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

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

type validateOpDescribePullRequestEvents struct {
}

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

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

type validateOpDisassociateApprovalRuleTemplateFromRepository struct {
}

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

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

type validateOpEvaluatePullRequestApprovalRules struct {
}

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

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

type validateOpGetApprovalRuleTemplate struct {
}

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

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

type validateOpGetBlob struct {
}

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

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

type validateOpGetComment struct {
}

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

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

type validateOpGetCommentReactions struct {
}

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

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

type validateOpGetCommentsForComparedCommit struct {
}

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

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

type validateOpGetCommentsForPullRequest struct {
}

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

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

type validateOpGetCommit struct {
}

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

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

type validateOpGetDifferences struct {
}

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

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

type validateOpGetFile struct {
}

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

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

type validateOpGetFolder struct {
}

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

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

type validateOpGetMergeCommit struct {
}

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

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

type validateOpGetMergeConflicts struct {
}

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

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

type validateOpGetMergeOptions struct {
}

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

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

type validateOpGetPullRequestApprovalStates struct {
}

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

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

type validateOpGetPullRequest struct {
}

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

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

type validateOpGetPullRequestOverrideState struct {
}

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

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

type validateOpGetRepository struct {
}

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

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

type validateOpGetRepositoryTriggers struct {
}

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

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

type validateOpListAssociatedApprovalRuleTemplatesForRepository struct {
}

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

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

type validateOpListBranches struct {
}

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

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

type validateOpListFileCommitHistory struct {
}

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

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

type validateOpListPullRequests struct {
}

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

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

type validateOpListRepositoriesForApprovalRuleTemplate struct {
}

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

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

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

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

type validateOpMergeBranchesBySquash struct {
}

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

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

type validateOpMergeBranchesByThreeWay struct {
}

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

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

type validateOpMergePullRequestByFastForward struct {
}

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

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

type validateOpMergePullRequestBySquash struct {
}

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

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

type validateOpMergePullRequestByThreeWay struct {
}

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

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

type validateOpOverridePullRequestApprovalRules struct {
}

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

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

type validateOpPostCommentForComparedCommit struct {
}

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

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

type validateOpPostCommentForPullRequest struct {
}

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

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

type validateOpPostCommentReply struct {
}

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

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

type validateOpPutCommentReaction struct {
}

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

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

type validateOpPutFile struct {
}

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

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

type validateOpPutRepositoryTriggers struct {
}

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

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

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

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

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

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

type validateOpUpdateApprovalRuleTemplateDescription struct {
}

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

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

type validateOpUpdateApprovalRuleTemplateName struct {
}

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

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

type validateOpUpdateComment struct {
}

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

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

type validateOpUpdateDefaultBranch struct {
}

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

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

type validateOpUpdatePullRequestApprovalRuleContent struct {
}

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

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

type validateOpUpdatePullRequestApprovalState struct {
}

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

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

type validateOpUpdatePullRequestDescription struct {
}

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

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

type validateOpUpdatePullRequestStatus struct {
}

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

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

type validateOpUpdatePullRequestTitle struct {
}

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

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

type validateOpUpdateRepositoryDescription struct {
}

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

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

type validateOpUpdateRepositoryEncryptionKey struct {
}

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

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

type validateOpUpdateRepositoryName struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateConflictResolution(v *types.ConflictResolution) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConflictResolution"}
	if v.ReplaceContents != nil {
		if err := validateReplaceContentEntries(v.ReplaceContents); err != nil {
			invalidParams.AddNested("ReplaceContents", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeleteFiles != nil {
		if err := validateDeleteFileEntries(v.DeleteFiles); err != nil {
			invalidParams.AddNested("DeleteFiles", err.(smithy.InvalidParamsError))
		}
	}
	if v.SetFileModes != nil {
		if err := validateSetFileModeEntries(v.SetFileModes); err != nil {
			invalidParams.AddNested("SetFileModes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validatePutFileEntry(v *types.PutFileEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutFileEntry"}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if v.SourceFile != nil {
		if err := validateSourceFileSpecifier(v.SourceFile); err != nil {
			invalidParams.AddNested("SourceFile", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateReplaceContentEntry(v *types.ReplaceContentEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceContentEntry"}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if len(v.ReplacementType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ReplacementType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRepositoryTrigger(v *types.RepositoryTrigger) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RepositoryTrigger"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DestinationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationArn"))
	}
	if v.Events == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Events"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSetFileModeEntry(v *types.SetFileModeEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetFileModeEntry"}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if len(v.FileMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FileMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTarget(v *types.Target) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Target"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.SourceReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateApprovalRuleTemplateWithRepositoryInput(v *AssociateApprovalRuleTemplateWithRepositoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateApprovalRuleTemplateWithRepositoryInput"}
	if v.ApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateName"))
	}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchAssociateApprovalRuleTemplateWithRepositoriesInput(v *BatchAssociateApprovalRuleTemplateWithRepositoriesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAssociateApprovalRuleTemplateWithRepositoriesInput"}
	if v.ApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateName"))
	}
	if v.RepositoryNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDescribeMergeConflictsInput(v *BatchDescribeMergeConflictsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDescribeMergeConflictsInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if len(v.MergeOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MergeOption"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDisassociateApprovalRuleTemplateFromRepositoriesInput(v *BatchDisassociateApprovalRuleTemplateFromRepositoriesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDisassociateApprovalRuleTemplateFromRepositoriesInput"}
	if v.ApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateName"))
	}
	if v.RepositoryNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetCommitsInput(v *BatchGetCommitsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetCommitsInput"}
	if v.CommitIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommitIds"))
	}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateApprovalRuleTemplateInput(v *CreateApprovalRuleTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateApprovalRuleTemplateInput"}
	if v.ApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateName"))
	}
	if v.ApprovalRuleTemplateContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateContent"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBranchInput(v *CreateBranchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBranchInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.BranchName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
	}
	if v.CommitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCommitInput(v *CreateCommitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCommitInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.BranchName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
	}
	if v.PutFiles != nil {
		if err := validatePutFileEntries(v.PutFiles); err != nil {
			invalidParams.AddNested("PutFiles", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeleteFiles != nil {
		if err := validateDeleteFileEntries(v.DeleteFiles); err != nil {
			invalidParams.AddNested("DeleteFiles", err.(smithy.InvalidParamsError))
		}
	}
	if v.SetFileModes != nil {
		if err := validateSetFileModeEntries(v.SetFileModes); err != nil {
			invalidParams.AddNested("SetFileModes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePullRequestApprovalRuleInput(v *CreatePullRequestApprovalRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePullRequestApprovalRuleInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.ApprovalRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleName"))
	}
	if v.ApprovalRuleContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleContent"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePullRequestInput(v *CreatePullRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePullRequestInput"}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.Targets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
	} else if v.Targets != nil {
		if err := validateTargetList(v.Targets); err != nil {
			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateUnreferencedMergeCommitInput(v *CreateUnreferencedMergeCommitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUnreferencedMergeCommitInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if len(v.MergeOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MergeOption"))
	}
	if v.ConflictResolution != nil {
		if err := validateConflictResolution(v.ConflictResolution); err != nil {
			invalidParams.AddNested("ConflictResolution", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteBranchInput(v *DeleteBranchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBranchInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.BranchName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteFileInput(v *DeleteFileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFileInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.BranchName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
	}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if v.ParentCommitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentCommitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePullRequestApprovalRuleInput(v *DeletePullRequestApprovalRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePullRequestApprovalRuleInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.ApprovalRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeMergeConflictsInput(v *DescribeMergeConflictsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMergeConflictsInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if len(v.MergeOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MergeOption"))
	}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDisassociateApprovalRuleTemplateFromRepositoryInput(v *DisassociateApprovalRuleTemplateFromRepositoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateApprovalRuleTemplateFromRepositoryInput"}
	if v.ApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateName"))
	}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEvaluatePullRequestApprovalRulesInput(v *EvaluatePullRequestApprovalRulesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluatePullRequestApprovalRulesInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RevisionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RevisionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetBlobInput(v *GetBlobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetBlobInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.BlobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetCommentsForComparedCommitInput(v *GetCommentsForComparedCommitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCommentsForComparedCommitInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.AfterCommitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AfterCommitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetCommitInput(v *GetCommitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCommitInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.CommitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDifferencesInput(v *GetDifferencesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDifferencesInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.AfterCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AfterCommitSpecifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFileInput(v *GetFileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFileInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFolderInput(v *GetFolderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFolderInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.FolderPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderPath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMergeCommitInput(v *GetMergeCommitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMergeCommitInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMergeConflictsInput(v *GetMergeConflictsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMergeConflictsInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if len(v.MergeOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MergeOption"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMergeOptionsInput(v *GetMergeOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMergeOptionsInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPullRequestApprovalStatesInput(v *GetPullRequestApprovalStatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPullRequestApprovalStatesInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RevisionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RevisionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetPullRequestOverrideStateInput(v *GetPullRequestOverrideStateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPullRequestOverrideStateInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RevisionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RevisionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpListFileCommitHistoryInput(v *ListFileCommitHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListFileCommitHistoryInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListRepositoriesForApprovalRuleTemplateInput(v *ListRepositoriesForApprovalRuleTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRepositoriesForApprovalRuleTemplateInput"}
	if v.ApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateName"))
	}
	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 validateOpMergeBranchesByFastForwardInput(v *MergeBranchesByFastForwardInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MergeBranchesByFastForwardInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMergeBranchesBySquashInput(v *MergeBranchesBySquashInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MergeBranchesBySquashInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if v.ConflictResolution != nil {
		if err := validateConflictResolution(v.ConflictResolution); err != nil {
			invalidParams.AddNested("ConflictResolution", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMergeBranchesByThreeWayInput(v *MergeBranchesByThreeWayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MergeBranchesByThreeWayInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.SourceCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCommitSpecifier"))
	}
	if v.DestinationCommitSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCommitSpecifier"))
	}
	if v.ConflictResolution != nil {
		if err := validateConflictResolution(v.ConflictResolution); err != nil {
			invalidParams.AddNested("ConflictResolution", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMergePullRequestByFastForwardInput(v *MergePullRequestByFastForwardInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MergePullRequestByFastForwardInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMergePullRequestBySquashInput(v *MergePullRequestBySquashInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MergePullRequestBySquashInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.ConflictResolution != nil {
		if err := validateConflictResolution(v.ConflictResolution); err != nil {
			invalidParams.AddNested("ConflictResolution", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMergePullRequestByThreeWayInput(v *MergePullRequestByThreeWayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MergePullRequestByThreeWayInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.ConflictResolution != nil {
		if err := validateConflictResolution(v.ConflictResolution); err != nil {
			invalidParams.AddNested("ConflictResolution", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpOverridePullRequestApprovalRulesInput(v *OverridePullRequestApprovalRulesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OverridePullRequestApprovalRulesInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RevisionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RevisionId"))
	}
	if len(v.OverrideStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OverrideStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPostCommentForComparedCommitInput(v *PostCommentForComparedCommitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostCommentForComparedCommitInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.AfterCommitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AfterCommitId"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPostCommentForPullRequestInput(v *PostCommentForPullRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostCommentForPullRequestInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.BeforeCommitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BeforeCommitId"))
	}
	if v.AfterCommitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AfterCommitId"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPostCommentReplyInput(v *PostCommentReplyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostCommentReplyInput"}
	if v.InReplyTo == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InReplyTo"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutCommentReactionInput(v *PutCommentReactionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutCommentReactionInput"}
	if v.CommentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommentId"))
	}
	if v.ReactionValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReactionValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutFileInput(v *PutFileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutFileInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.BranchName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
	}
	if v.FileContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileContent"))
	}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutRepositoryTriggersInput(v *PutRepositoryTriggersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRepositoryTriggersInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.Triggers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Triggers"))
	} else if v.Triggers != nil {
		if err := validateRepositoryTriggersList(v.Triggers); err != nil {
			invalidParams.AddNested("Triggers", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpTestRepositoryTriggersInput(v *TestRepositoryTriggersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestRepositoryTriggersInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.Triggers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Triggers"))
	} else if v.Triggers != nil {
		if err := validateRepositoryTriggersList(v.Triggers); err != nil {
			invalidParams.AddNested("Triggers", 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.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 validateOpUpdateApprovalRuleTemplateContentInput(v *UpdateApprovalRuleTemplateContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApprovalRuleTemplateContentInput"}
	if v.ApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateName"))
	}
	if v.NewRuleContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewRuleContent"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApprovalRuleTemplateDescriptionInput(v *UpdateApprovalRuleTemplateDescriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApprovalRuleTemplateDescriptionInput"}
	if v.ApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateName"))
	}
	if v.ApprovalRuleTemplateDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleTemplateDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApprovalRuleTemplateNameInput(v *UpdateApprovalRuleTemplateNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApprovalRuleTemplateNameInput"}
	if v.OldApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OldApprovalRuleTemplateName"))
	}
	if v.NewApprovalRuleTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewApprovalRuleTemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCommentInput(v *UpdateCommentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCommentInput"}
	if v.CommentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommentId"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDefaultBranchInput(v *UpdateDefaultBranchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDefaultBranchInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.DefaultBranchName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultBranchName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePullRequestApprovalRuleContentInput(v *UpdatePullRequestApprovalRuleContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePullRequestApprovalRuleContentInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.ApprovalRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalRuleName"))
	}
	if v.NewRuleContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewRuleContent"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePullRequestApprovalStateInput(v *UpdatePullRequestApprovalStateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePullRequestApprovalStateInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.RevisionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RevisionId"))
	}
	if len(v.ApprovalState) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ApprovalState"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePullRequestDescriptionInput(v *UpdatePullRequestDescriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePullRequestDescriptionInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePullRequestStatusInput(v *UpdatePullRequestStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePullRequestStatusInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if len(v.PullRequestStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePullRequestTitleInput(v *UpdatePullRequestTitleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePullRequestTitleInput"}
	if v.PullRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PullRequestId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateRepositoryEncryptionKeyInput(v *UpdateRepositoryEncryptionKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRepositoryEncryptionKeyInput"}
	if v.RepositoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
	}
	if v.KmsKeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KmsKeyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRepositoryNameInput(v *UpdateRepositoryNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRepositoryNameInput"}
	if v.OldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OldName"))
	}
	if v.NewName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}