driftctl/test/aws/mock_FakeECR.go

// Code generated by mockery v1.0.0. DO NOT EDIT.

package aws

import (
	context "context"

	ecr "github.com/aws/aws-sdk-go/service/ecr"
	mock "github.com/stretchr/testify/mock"

	request "github.com/aws/aws-sdk-go/aws/request"
)

// MockFakeECR is an autogenerated mock type for the FakeECR type
type MockFakeECR struct {
	mock.Mock
}

// BatchCheckLayerAvailability provides a mock function with given fields: _a0
func (_m *MockFakeECR) BatchCheckLayerAvailability(_a0 *ecr.BatchCheckLayerAvailabilityInput) (*ecr.BatchCheckLayerAvailabilityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.BatchCheckLayerAvailabilityOutput
	if rf, ok := ret.Get(0).(func(*ecr.BatchCheckLayerAvailabilityInput) *ecr.BatchCheckLayerAvailabilityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.BatchCheckLayerAvailabilityOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.BatchCheckLayerAvailabilityInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchCheckLayerAvailabilityRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) BatchCheckLayerAvailabilityRequest(_a0 *ecr.BatchCheckLayerAvailabilityInput) (*request.Request, *ecr.BatchCheckLayerAvailabilityOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.BatchCheckLayerAvailabilityInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.BatchCheckLayerAvailabilityOutput
	if rf, ok := ret.Get(1).(func(*ecr.BatchCheckLayerAvailabilityInput) *ecr.BatchCheckLayerAvailabilityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.BatchCheckLayerAvailabilityOutput)
		}
	}

	return r0, r1
}

// BatchCheckLayerAvailabilityWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) BatchCheckLayerAvailabilityWithContext(_a0 context.Context, _a1 *ecr.BatchCheckLayerAvailabilityInput, _a2 ...request.Option) (*ecr.BatchCheckLayerAvailabilityOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.BatchCheckLayerAvailabilityOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.BatchCheckLayerAvailabilityInput, ...request.Option) *ecr.BatchCheckLayerAvailabilityOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.BatchCheckLayerAvailabilityOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.BatchCheckLayerAvailabilityInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchDeleteImage provides a mock function with given fields: _a0
func (_m *MockFakeECR) BatchDeleteImage(_a0 *ecr.BatchDeleteImageInput) (*ecr.BatchDeleteImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.BatchDeleteImageOutput
	if rf, ok := ret.Get(0).(func(*ecr.BatchDeleteImageInput) *ecr.BatchDeleteImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.BatchDeleteImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.BatchDeleteImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchDeleteImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) BatchDeleteImageRequest(_a0 *ecr.BatchDeleteImageInput) (*request.Request, *ecr.BatchDeleteImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.BatchDeleteImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.BatchDeleteImageOutput
	if rf, ok := ret.Get(1).(func(*ecr.BatchDeleteImageInput) *ecr.BatchDeleteImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.BatchDeleteImageOutput)
		}
	}

	return r0, r1
}

// BatchDeleteImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) BatchDeleteImageWithContext(_a0 context.Context, _a1 *ecr.BatchDeleteImageInput, _a2 ...request.Option) (*ecr.BatchDeleteImageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.BatchDeleteImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.BatchDeleteImageInput, ...request.Option) *ecr.BatchDeleteImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.BatchDeleteImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.BatchDeleteImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchGetImage provides a mock function with given fields: _a0
func (_m *MockFakeECR) BatchGetImage(_a0 *ecr.BatchGetImageInput) (*ecr.BatchGetImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.BatchGetImageOutput
	if rf, ok := ret.Get(0).(func(*ecr.BatchGetImageInput) *ecr.BatchGetImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.BatchGetImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.BatchGetImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchGetImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) BatchGetImageRequest(_a0 *ecr.BatchGetImageInput) (*request.Request, *ecr.BatchGetImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.BatchGetImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.BatchGetImageOutput
	if rf, ok := ret.Get(1).(func(*ecr.BatchGetImageInput) *ecr.BatchGetImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.BatchGetImageOutput)
		}
	}

	return r0, r1
}

// BatchGetImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) BatchGetImageWithContext(_a0 context.Context, _a1 *ecr.BatchGetImageInput, _a2 ...request.Option) (*ecr.BatchGetImageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.BatchGetImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.BatchGetImageInput, ...request.Option) *ecr.BatchGetImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.BatchGetImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.BatchGetImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CompleteLayerUpload provides a mock function with given fields: _a0
func (_m *MockFakeECR) CompleteLayerUpload(_a0 *ecr.CompleteLayerUploadInput) (*ecr.CompleteLayerUploadOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.CompleteLayerUploadOutput
	if rf, ok := ret.Get(0).(func(*ecr.CompleteLayerUploadInput) *ecr.CompleteLayerUploadOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.CompleteLayerUploadOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.CompleteLayerUploadInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CompleteLayerUploadRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) CompleteLayerUploadRequest(_a0 *ecr.CompleteLayerUploadInput) (*request.Request, *ecr.CompleteLayerUploadOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.CompleteLayerUploadInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.CompleteLayerUploadOutput
	if rf, ok := ret.Get(1).(func(*ecr.CompleteLayerUploadInput) *ecr.CompleteLayerUploadOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.CompleteLayerUploadOutput)
		}
	}

	return r0, r1
}

// CompleteLayerUploadWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) CompleteLayerUploadWithContext(_a0 context.Context, _a1 *ecr.CompleteLayerUploadInput, _a2 ...request.Option) (*ecr.CompleteLayerUploadOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.CompleteLayerUploadOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.CompleteLayerUploadInput, ...request.Option) *ecr.CompleteLayerUploadOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.CompleteLayerUploadOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.CompleteLayerUploadInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateRepository provides a mock function with given fields: _a0
func (_m *MockFakeECR) CreateRepository(_a0 *ecr.CreateRepositoryInput) (*ecr.CreateRepositoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.CreateRepositoryOutput
	if rf, ok := ret.Get(0).(func(*ecr.CreateRepositoryInput) *ecr.CreateRepositoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.CreateRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.CreateRepositoryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateRepositoryRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) CreateRepositoryRequest(_a0 *ecr.CreateRepositoryInput) (*request.Request, *ecr.CreateRepositoryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.CreateRepositoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.CreateRepositoryOutput
	if rf, ok := ret.Get(1).(func(*ecr.CreateRepositoryInput) *ecr.CreateRepositoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.CreateRepositoryOutput)
		}
	}

	return r0, r1
}

// CreateRepositoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) CreateRepositoryWithContext(_a0 context.Context, _a1 *ecr.CreateRepositoryInput, _a2 ...request.Option) (*ecr.CreateRepositoryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.CreateRepositoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.CreateRepositoryInput, ...request.Option) *ecr.CreateRepositoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.CreateRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.CreateRepositoryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteLifecyclePolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) DeleteLifecyclePolicy(_a0 *ecr.DeleteLifecyclePolicyInput) (*ecr.DeleteLifecyclePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.DeleteLifecyclePolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.DeleteLifecyclePolicyInput) *ecr.DeleteLifecyclePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeleteLifecyclePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.DeleteLifecyclePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteLifecyclePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) DeleteLifecyclePolicyRequest(_a0 *ecr.DeleteLifecyclePolicyInput) (*request.Request, *ecr.DeleteLifecyclePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.DeleteLifecyclePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.DeleteLifecyclePolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.DeleteLifecyclePolicyInput) *ecr.DeleteLifecyclePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.DeleteLifecyclePolicyOutput)
		}
	}

	return r0, r1
}

// DeleteLifecyclePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) DeleteLifecyclePolicyWithContext(_a0 context.Context, _a1 *ecr.DeleteLifecyclePolicyInput, _a2 ...request.Option) (*ecr.DeleteLifecyclePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.DeleteLifecyclePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DeleteLifecyclePolicyInput, ...request.Option) *ecr.DeleteLifecyclePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeleteLifecyclePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DeleteLifecyclePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRegistryPolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) DeleteRegistryPolicy(_a0 *ecr.DeleteRegistryPolicyInput) (*ecr.DeleteRegistryPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.DeleteRegistryPolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.DeleteRegistryPolicyInput) *ecr.DeleteRegistryPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeleteRegistryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.DeleteRegistryPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRegistryPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) DeleteRegistryPolicyRequest(_a0 *ecr.DeleteRegistryPolicyInput) (*request.Request, *ecr.DeleteRegistryPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.DeleteRegistryPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.DeleteRegistryPolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.DeleteRegistryPolicyInput) *ecr.DeleteRegistryPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.DeleteRegistryPolicyOutput)
		}
	}

	return r0, r1
}

// DeleteRegistryPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) DeleteRegistryPolicyWithContext(_a0 context.Context, _a1 *ecr.DeleteRegistryPolicyInput, _a2 ...request.Option) (*ecr.DeleteRegistryPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.DeleteRegistryPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DeleteRegistryPolicyInput, ...request.Option) *ecr.DeleteRegistryPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeleteRegistryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DeleteRegistryPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRepository provides a mock function with given fields: _a0
func (_m *MockFakeECR) DeleteRepository(_a0 *ecr.DeleteRepositoryInput) (*ecr.DeleteRepositoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.DeleteRepositoryOutput
	if rf, ok := ret.Get(0).(func(*ecr.DeleteRepositoryInput) *ecr.DeleteRepositoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeleteRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.DeleteRepositoryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRepositoryPolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) DeleteRepositoryPolicy(_a0 *ecr.DeleteRepositoryPolicyInput) (*ecr.DeleteRepositoryPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.DeleteRepositoryPolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.DeleteRepositoryPolicyInput) *ecr.DeleteRepositoryPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeleteRepositoryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.DeleteRepositoryPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRepositoryPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) DeleteRepositoryPolicyRequest(_a0 *ecr.DeleteRepositoryPolicyInput) (*request.Request, *ecr.DeleteRepositoryPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.DeleteRepositoryPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.DeleteRepositoryPolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.DeleteRepositoryPolicyInput) *ecr.DeleteRepositoryPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.DeleteRepositoryPolicyOutput)
		}
	}

	return r0, r1
}

// DeleteRepositoryPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) DeleteRepositoryPolicyWithContext(_a0 context.Context, _a1 *ecr.DeleteRepositoryPolicyInput, _a2 ...request.Option) (*ecr.DeleteRepositoryPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.DeleteRepositoryPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DeleteRepositoryPolicyInput, ...request.Option) *ecr.DeleteRepositoryPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeleteRepositoryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DeleteRepositoryPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRepositoryRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) DeleteRepositoryRequest(_a0 *ecr.DeleteRepositoryInput) (*request.Request, *ecr.DeleteRepositoryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.DeleteRepositoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.DeleteRepositoryOutput
	if rf, ok := ret.Get(1).(func(*ecr.DeleteRepositoryInput) *ecr.DeleteRepositoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.DeleteRepositoryOutput)
		}
	}

	return r0, r1
}

// DeleteRepositoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) DeleteRepositoryWithContext(_a0 context.Context, _a1 *ecr.DeleteRepositoryInput, _a2 ...request.Option) (*ecr.DeleteRepositoryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.DeleteRepositoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DeleteRepositoryInput, ...request.Option) *ecr.DeleteRepositoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeleteRepositoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DeleteRepositoryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeImageScanFindings provides a mock function with given fields: _a0
func (_m *MockFakeECR) DescribeImageScanFindings(_a0 *ecr.DescribeImageScanFindingsInput) (*ecr.DescribeImageScanFindingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.DescribeImageScanFindingsOutput
	if rf, ok := ret.Get(0).(func(*ecr.DescribeImageScanFindingsInput) *ecr.DescribeImageScanFindingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeImageScanFindingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.DescribeImageScanFindingsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeImageScanFindingsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeECR) DescribeImageScanFindingsPages(_a0 *ecr.DescribeImageScanFindingsInput, _a1 func(*ecr.DescribeImageScanFindingsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecr.DescribeImageScanFindingsInput, func(*ecr.DescribeImageScanFindingsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeImageScanFindingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeECR) DescribeImageScanFindingsPagesWithContext(_a0 context.Context, _a1 *ecr.DescribeImageScanFindingsInput, _a2 func(*ecr.DescribeImageScanFindingsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeImageScanFindingsInput, func(*ecr.DescribeImageScanFindingsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeImageScanFindingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) DescribeImageScanFindingsRequest(_a0 *ecr.DescribeImageScanFindingsInput) (*request.Request, *ecr.DescribeImageScanFindingsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.DescribeImageScanFindingsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.DescribeImageScanFindingsOutput
	if rf, ok := ret.Get(1).(func(*ecr.DescribeImageScanFindingsInput) *ecr.DescribeImageScanFindingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.DescribeImageScanFindingsOutput)
		}
	}

	return r0, r1
}

// DescribeImageScanFindingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) DescribeImageScanFindingsWithContext(_a0 context.Context, _a1 *ecr.DescribeImageScanFindingsInput, _a2 ...request.Option) (*ecr.DescribeImageScanFindingsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.DescribeImageScanFindingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeImageScanFindingsInput, ...request.Option) *ecr.DescribeImageScanFindingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeImageScanFindingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DescribeImageScanFindingsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeImages provides a mock function with given fields: _a0
func (_m *MockFakeECR) DescribeImages(_a0 *ecr.DescribeImagesInput) (*ecr.DescribeImagesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.DescribeImagesOutput
	if rf, ok := ret.Get(0).(func(*ecr.DescribeImagesInput) *ecr.DescribeImagesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeImagesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.DescribeImagesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeImagesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeECR) DescribeImagesPages(_a0 *ecr.DescribeImagesInput, _a1 func(*ecr.DescribeImagesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecr.DescribeImagesInput, func(*ecr.DescribeImagesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeImagesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeECR) DescribeImagesPagesWithContext(_a0 context.Context, _a1 *ecr.DescribeImagesInput, _a2 func(*ecr.DescribeImagesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeImagesInput, func(*ecr.DescribeImagesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeImagesRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) DescribeImagesRequest(_a0 *ecr.DescribeImagesInput) (*request.Request, *ecr.DescribeImagesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.DescribeImagesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.DescribeImagesOutput
	if rf, ok := ret.Get(1).(func(*ecr.DescribeImagesInput) *ecr.DescribeImagesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.DescribeImagesOutput)
		}
	}

	return r0, r1
}

// DescribeImagesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) DescribeImagesWithContext(_a0 context.Context, _a1 *ecr.DescribeImagesInput, _a2 ...request.Option) (*ecr.DescribeImagesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.DescribeImagesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeImagesInput, ...request.Option) *ecr.DescribeImagesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeImagesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DescribeImagesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeRegistry provides a mock function with given fields: _a0
func (_m *MockFakeECR) DescribeRegistry(_a0 *ecr.DescribeRegistryInput) (*ecr.DescribeRegistryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.DescribeRegistryOutput
	if rf, ok := ret.Get(0).(func(*ecr.DescribeRegistryInput) *ecr.DescribeRegistryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeRegistryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.DescribeRegistryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeRegistryRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) DescribeRegistryRequest(_a0 *ecr.DescribeRegistryInput) (*request.Request, *ecr.DescribeRegistryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.DescribeRegistryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.DescribeRegistryOutput
	if rf, ok := ret.Get(1).(func(*ecr.DescribeRegistryInput) *ecr.DescribeRegistryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.DescribeRegistryOutput)
		}
	}

	return r0, r1
}

// DescribeRegistryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) DescribeRegistryWithContext(_a0 context.Context, _a1 *ecr.DescribeRegistryInput, _a2 ...request.Option) (*ecr.DescribeRegistryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.DescribeRegistryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeRegistryInput, ...request.Option) *ecr.DescribeRegistryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeRegistryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DescribeRegistryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeRepositories provides a mock function with given fields: _a0
func (_m *MockFakeECR) DescribeRepositories(_a0 *ecr.DescribeRepositoriesInput) (*ecr.DescribeRepositoriesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.DescribeRepositoriesOutput
	if rf, ok := ret.Get(0).(func(*ecr.DescribeRepositoriesInput) *ecr.DescribeRepositoriesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeRepositoriesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.DescribeRepositoriesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeRepositoriesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeECR) DescribeRepositoriesPages(_a0 *ecr.DescribeRepositoriesInput, _a1 func(*ecr.DescribeRepositoriesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecr.DescribeRepositoriesInput, func(*ecr.DescribeRepositoriesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeRepositoriesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeECR) DescribeRepositoriesPagesWithContext(_a0 context.Context, _a1 *ecr.DescribeRepositoriesInput, _a2 func(*ecr.DescribeRepositoriesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeRepositoriesInput, func(*ecr.DescribeRepositoriesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeRepositoriesRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) DescribeRepositoriesRequest(_a0 *ecr.DescribeRepositoriesInput) (*request.Request, *ecr.DescribeRepositoriesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.DescribeRepositoriesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.DescribeRepositoriesOutput
	if rf, ok := ret.Get(1).(func(*ecr.DescribeRepositoriesInput) *ecr.DescribeRepositoriesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.DescribeRepositoriesOutput)
		}
	}

	return r0, r1
}

// DescribeRepositoriesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) DescribeRepositoriesWithContext(_a0 context.Context, _a1 *ecr.DescribeRepositoriesInput, _a2 ...request.Option) (*ecr.DescribeRepositoriesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.DescribeRepositoriesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeRepositoriesInput, ...request.Option) *ecr.DescribeRepositoriesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeRepositoriesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DescribeRepositoriesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAuthorizationToken provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetAuthorizationToken(_a0 *ecr.GetAuthorizationTokenInput) (*ecr.GetAuthorizationTokenOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.GetAuthorizationTokenOutput
	if rf, ok := ret.Get(0).(func(*ecr.GetAuthorizationTokenInput) *ecr.GetAuthorizationTokenOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetAuthorizationTokenOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.GetAuthorizationTokenInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAuthorizationTokenRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetAuthorizationTokenRequest(_a0 *ecr.GetAuthorizationTokenInput) (*request.Request, *ecr.GetAuthorizationTokenOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.GetAuthorizationTokenInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.GetAuthorizationTokenOutput
	if rf, ok := ret.Get(1).(func(*ecr.GetAuthorizationTokenInput) *ecr.GetAuthorizationTokenOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.GetAuthorizationTokenOutput)
		}
	}

	return r0, r1
}

// GetAuthorizationTokenWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) GetAuthorizationTokenWithContext(_a0 context.Context, _a1 *ecr.GetAuthorizationTokenInput, _a2 ...request.Option) (*ecr.GetAuthorizationTokenOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.GetAuthorizationTokenOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetAuthorizationTokenInput, ...request.Option) *ecr.GetAuthorizationTokenOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetAuthorizationTokenOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.GetAuthorizationTokenInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetDownloadUrlForLayer provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetDownloadUrlForLayer(_a0 *ecr.GetDownloadUrlForLayerInput) (*ecr.GetDownloadUrlForLayerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.GetDownloadUrlForLayerOutput
	if rf, ok := ret.Get(0).(func(*ecr.GetDownloadUrlForLayerInput) *ecr.GetDownloadUrlForLayerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetDownloadUrlForLayerOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.GetDownloadUrlForLayerInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetDownloadUrlForLayerRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetDownloadUrlForLayerRequest(_a0 *ecr.GetDownloadUrlForLayerInput) (*request.Request, *ecr.GetDownloadUrlForLayerOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.GetDownloadUrlForLayerInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.GetDownloadUrlForLayerOutput
	if rf, ok := ret.Get(1).(func(*ecr.GetDownloadUrlForLayerInput) *ecr.GetDownloadUrlForLayerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.GetDownloadUrlForLayerOutput)
		}
	}

	return r0, r1
}

// GetDownloadUrlForLayerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) GetDownloadUrlForLayerWithContext(_a0 context.Context, _a1 *ecr.GetDownloadUrlForLayerInput, _a2 ...request.Option) (*ecr.GetDownloadUrlForLayerOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.GetDownloadUrlForLayerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetDownloadUrlForLayerInput, ...request.Option) *ecr.GetDownloadUrlForLayerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetDownloadUrlForLayerOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.GetDownloadUrlForLayerInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLifecyclePolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetLifecyclePolicy(_a0 *ecr.GetLifecyclePolicyInput) (*ecr.GetLifecyclePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.GetLifecyclePolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.GetLifecyclePolicyInput) *ecr.GetLifecyclePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetLifecyclePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.GetLifecyclePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLifecyclePolicyPreview provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetLifecyclePolicyPreview(_a0 *ecr.GetLifecyclePolicyPreviewInput) (*ecr.GetLifecyclePolicyPreviewOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.GetLifecyclePolicyPreviewOutput
	if rf, ok := ret.Get(0).(func(*ecr.GetLifecyclePolicyPreviewInput) *ecr.GetLifecyclePolicyPreviewOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetLifecyclePolicyPreviewOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.GetLifecyclePolicyPreviewInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLifecyclePolicyPreviewPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeECR) GetLifecyclePolicyPreviewPages(_a0 *ecr.GetLifecyclePolicyPreviewInput, _a1 func(*ecr.GetLifecyclePolicyPreviewOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecr.GetLifecyclePolicyPreviewInput, func(*ecr.GetLifecyclePolicyPreviewOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetLifecyclePolicyPreviewPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeECR) GetLifecyclePolicyPreviewPagesWithContext(_a0 context.Context, _a1 *ecr.GetLifecyclePolicyPreviewInput, _a2 func(*ecr.GetLifecyclePolicyPreviewOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetLifecyclePolicyPreviewInput, func(*ecr.GetLifecyclePolicyPreviewOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetLifecyclePolicyPreviewRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetLifecyclePolicyPreviewRequest(_a0 *ecr.GetLifecyclePolicyPreviewInput) (*request.Request, *ecr.GetLifecyclePolicyPreviewOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.GetLifecyclePolicyPreviewInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.GetLifecyclePolicyPreviewOutput
	if rf, ok := ret.Get(1).(func(*ecr.GetLifecyclePolicyPreviewInput) *ecr.GetLifecyclePolicyPreviewOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.GetLifecyclePolicyPreviewOutput)
		}
	}

	return r0, r1
}

// GetLifecyclePolicyPreviewWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) GetLifecyclePolicyPreviewWithContext(_a0 context.Context, _a1 *ecr.GetLifecyclePolicyPreviewInput, _a2 ...request.Option) (*ecr.GetLifecyclePolicyPreviewOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.GetLifecyclePolicyPreviewOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetLifecyclePolicyPreviewInput, ...request.Option) *ecr.GetLifecyclePolicyPreviewOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetLifecyclePolicyPreviewOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.GetLifecyclePolicyPreviewInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLifecyclePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetLifecyclePolicyRequest(_a0 *ecr.GetLifecyclePolicyInput) (*request.Request, *ecr.GetLifecyclePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.GetLifecyclePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.GetLifecyclePolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.GetLifecyclePolicyInput) *ecr.GetLifecyclePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.GetLifecyclePolicyOutput)
		}
	}

	return r0, r1
}

// GetLifecyclePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) GetLifecyclePolicyWithContext(_a0 context.Context, _a1 *ecr.GetLifecyclePolicyInput, _a2 ...request.Option) (*ecr.GetLifecyclePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.GetLifecyclePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetLifecyclePolicyInput, ...request.Option) *ecr.GetLifecyclePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetLifecyclePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.GetLifecyclePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRegistryPolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetRegistryPolicy(_a0 *ecr.GetRegistryPolicyInput) (*ecr.GetRegistryPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.GetRegistryPolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.GetRegistryPolicyInput) *ecr.GetRegistryPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetRegistryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.GetRegistryPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRegistryPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetRegistryPolicyRequest(_a0 *ecr.GetRegistryPolicyInput) (*request.Request, *ecr.GetRegistryPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.GetRegistryPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.GetRegistryPolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.GetRegistryPolicyInput) *ecr.GetRegistryPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.GetRegistryPolicyOutput)
		}
	}

	return r0, r1
}

// GetRegistryPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) GetRegistryPolicyWithContext(_a0 context.Context, _a1 *ecr.GetRegistryPolicyInput, _a2 ...request.Option) (*ecr.GetRegistryPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.GetRegistryPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetRegistryPolicyInput, ...request.Option) *ecr.GetRegistryPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetRegistryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.GetRegistryPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRepositoryPolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetRepositoryPolicy(_a0 *ecr.GetRepositoryPolicyInput) (*ecr.GetRepositoryPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.GetRepositoryPolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.GetRepositoryPolicyInput) *ecr.GetRepositoryPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetRepositoryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.GetRepositoryPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRepositoryPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) GetRepositoryPolicyRequest(_a0 *ecr.GetRepositoryPolicyInput) (*request.Request, *ecr.GetRepositoryPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.GetRepositoryPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.GetRepositoryPolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.GetRepositoryPolicyInput) *ecr.GetRepositoryPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.GetRepositoryPolicyOutput)
		}
	}

	return r0, r1
}

// GetRepositoryPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) GetRepositoryPolicyWithContext(_a0 context.Context, _a1 *ecr.GetRepositoryPolicyInput, _a2 ...request.Option) (*ecr.GetRepositoryPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.GetRepositoryPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetRepositoryPolicyInput, ...request.Option) *ecr.GetRepositoryPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetRepositoryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.GetRepositoryPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// InitiateLayerUpload provides a mock function with given fields: _a0
func (_m *MockFakeECR) InitiateLayerUpload(_a0 *ecr.InitiateLayerUploadInput) (*ecr.InitiateLayerUploadOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.InitiateLayerUploadOutput
	if rf, ok := ret.Get(0).(func(*ecr.InitiateLayerUploadInput) *ecr.InitiateLayerUploadOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.InitiateLayerUploadOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.InitiateLayerUploadInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// InitiateLayerUploadRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) InitiateLayerUploadRequest(_a0 *ecr.InitiateLayerUploadInput) (*request.Request, *ecr.InitiateLayerUploadOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.InitiateLayerUploadInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.InitiateLayerUploadOutput
	if rf, ok := ret.Get(1).(func(*ecr.InitiateLayerUploadInput) *ecr.InitiateLayerUploadOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.InitiateLayerUploadOutput)
		}
	}

	return r0, r1
}

// InitiateLayerUploadWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) InitiateLayerUploadWithContext(_a0 context.Context, _a1 *ecr.InitiateLayerUploadInput, _a2 ...request.Option) (*ecr.InitiateLayerUploadOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.InitiateLayerUploadOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.InitiateLayerUploadInput, ...request.Option) *ecr.InitiateLayerUploadOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.InitiateLayerUploadOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.InitiateLayerUploadInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListImages provides a mock function with given fields: _a0
func (_m *MockFakeECR) ListImages(_a0 *ecr.ListImagesInput) (*ecr.ListImagesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.ListImagesOutput
	if rf, ok := ret.Get(0).(func(*ecr.ListImagesInput) *ecr.ListImagesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.ListImagesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.ListImagesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListImagesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeECR) ListImagesPages(_a0 *ecr.ListImagesInput, _a1 func(*ecr.ListImagesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecr.ListImagesInput, func(*ecr.ListImagesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListImagesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeECR) ListImagesPagesWithContext(_a0 context.Context, _a1 *ecr.ListImagesInput, _a2 func(*ecr.ListImagesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.ListImagesInput, func(*ecr.ListImagesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListImagesRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) ListImagesRequest(_a0 *ecr.ListImagesInput) (*request.Request, *ecr.ListImagesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.ListImagesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.ListImagesOutput
	if rf, ok := ret.Get(1).(func(*ecr.ListImagesInput) *ecr.ListImagesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.ListImagesOutput)
		}
	}

	return r0, r1
}

// ListImagesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) ListImagesWithContext(_a0 context.Context, _a1 *ecr.ListImagesInput, _a2 ...request.Option) (*ecr.ListImagesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.ListImagesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.ListImagesInput, ...request.Option) *ecr.ListImagesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.ListImagesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.ListImagesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResource provides a mock function with given fields: _a0
func (_m *MockFakeECR) ListTagsForResource(_a0 *ecr.ListTagsForResourceInput) (*ecr.ListTagsForResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(*ecr.ListTagsForResourceInput) *ecr.ListTagsForResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.ListTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.ListTagsForResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) ListTagsForResourceRequest(_a0 *ecr.ListTagsForResourceInput) (*request.Request, *ecr.ListTagsForResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.ListTagsForResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.ListTagsForResourceOutput
	if rf, ok := ret.Get(1).(func(*ecr.ListTagsForResourceInput) *ecr.ListTagsForResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.ListTagsForResourceOutput)
		}
	}

	return r0, r1
}

// ListTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) ListTagsForResourceWithContext(_a0 context.Context, _a1 *ecr.ListTagsForResourceInput, _a2 ...request.Option) (*ecr.ListTagsForResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.ListTagsForResourceInput, ...request.Option) *ecr.ListTagsForResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.ListTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.ListTagsForResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutImage provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutImage(_a0 *ecr.PutImageInput) (*ecr.PutImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.PutImageOutput
	if rf, ok := ret.Get(0).(func(*ecr.PutImageInput) *ecr.PutImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.PutImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutImageRequest(_a0 *ecr.PutImageInput) (*request.Request, *ecr.PutImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.PutImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.PutImageOutput
	if rf, ok := ret.Get(1).(func(*ecr.PutImageInput) *ecr.PutImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.PutImageOutput)
		}
	}

	return r0, r1
}

// PutImageScanningConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutImageScanningConfiguration(_a0 *ecr.PutImageScanningConfigurationInput) (*ecr.PutImageScanningConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.PutImageScanningConfigurationOutput
	if rf, ok := ret.Get(0).(func(*ecr.PutImageScanningConfigurationInput) *ecr.PutImageScanningConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutImageScanningConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.PutImageScanningConfigurationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutImageScanningConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutImageScanningConfigurationRequest(_a0 *ecr.PutImageScanningConfigurationInput) (*request.Request, *ecr.PutImageScanningConfigurationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.PutImageScanningConfigurationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.PutImageScanningConfigurationOutput
	if rf, ok := ret.Get(1).(func(*ecr.PutImageScanningConfigurationInput) *ecr.PutImageScanningConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.PutImageScanningConfigurationOutput)
		}
	}

	return r0, r1
}

// PutImageScanningConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) PutImageScanningConfigurationWithContext(_a0 context.Context, _a1 *ecr.PutImageScanningConfigurationInput, _a2 ...request.Option) (*ecr.PutImageScanningConfigurationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.PutImageScanningConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.PutImageScanningConfigurationInput, ...request.Option) *ecr.PutImageScanningConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutImageScanningConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.PutImageScanningConfigurationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutImageTagMutability provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutImageTagMutability(_a0 *ecr.PutImageTagMutabilityInput) (*ecr.PutImageTagMutabilityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.PutImageTagMutabilityOutput
	if rf, ok := ret.Get(0).(func(*ecr.PutImageTagMutabilityInput) *ecr.PutImageTagMutabilityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutImageTagMutabilityOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.PutImageTagMutabilityInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutImageTagMutabilityRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutImageTagMutabilityRequest(_a0 *ecr.PutImageTagMutabilityInput) (*request.Request, *ecr.PutImageTagMutabilityOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.PutImageTagMutabilityInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.PutImageTagMutabilityOutput
	if rf, ok := ret.Get(1).(func(*ecr.PutImageTagMutabilityInput) *ecr.PutImageTagMutabilityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.PutImageTagMutabilityOutput)
		}
	}

	return r0, r1
}

// PutImageTagMutabilityWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) PutImageTagMutabilityWithContext(_a0 context.Context, _a1 *ecr.PutImageTagMutabilityInput, _a2 ...request.Option) (*ecr.PutImageTagMutabilityOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.PutImageTagMutabilityOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.PutImageTagMutabilityInput, ...request.Option) *ecr.PutImageTagMutabilityOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutImageTagMutabilityOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.PutImageTagMutabilityInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) PutImageWithContext(_a0 context.Context, _a1 *ecr.PutImageInput, _a2 ...request.Option) (*ecr.PutImageOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.PutImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.PutImageInput, ...request.Option) *ecr.PutImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.PutImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutLifecyclePolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutLifecyclePolicy(_a0 *ecr.PutLifecyclePolicyInput) (*ecr.PutLifecyclePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.PutLifecyclePolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.PutLifecyclePolicyInput) *ecr.PutLifecyclePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutLifecyclePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.PutLifecyclePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutLifecyclePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutLifecyclePolicyRequest(_a0 *ecr.PutLifecyclePolicyInput) (*request.Request, *ecr.PutLifecyclePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.PutLifecyclePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.PutLifecyclePolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.PutLifecyclePolicyInput) *ecr.PutLifecyclePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.PutLifecyclePolicyOutput)
		}
	}

	return r0, r1
}

// PutLifecyclePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) PutLifecyclePolicyWithContext(_a0 context.Context, _a1 *ecr.PutLifecyclePolicyInput, _a2 ...request.Option) (*ecr.PutLifecyclePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.PutLifecyclePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.PutLifecyclePolicyInput, ...request.Option) *ecr.PutLifecyclePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutLifecyclePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.PutLifecyclePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutRegistryPolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutRegistryPolicy(_a0 *ecr.PutRegistryPolicyInput) (*ecr.PutRegistryPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.PutRegistryPolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.PutRegistryPolicyInput) *ecr.PutRegistryPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutRegistryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.PutRegistryPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutRegistryPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutRegistryPolicyRequest(_a0 *ecr.PutRegistryPolicyInput) (*request.Request, *ecr.PutRegistryPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.PutRegistryPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.PutRegistryPolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.PutRegistryPolicyInput) *ecr.PutRegistryPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.PutRegistryPolicyOutput)
		}
	}

	return r0, r1
}

// PutRegistryPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) PutRegistryPolicyWithContext(_a0 context.Context, _a1 *ecr.PutRegistryPolicyInput, _a2 ...request.Option) (*ecr.PutRegistryPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.PutRegistryPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.PutRegistryPolicyInput, ...request.Option) *ecr.PutRegistryPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutRegistryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.PutRegistryPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutReplicationConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutReplicationConfiguration(_a0 *ecr.PutReplicationConfigurationInput) (*ecr.PutReplicationConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.PutReplicationConfigurationOutput
	if rf, ok := ret.Get(0).(func(*ecr.PutReplicationConfigurationInput) *ecr.PutReplicationConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutReplicationConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.PutReplicationConfigurationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutReplicationConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) PutReplicationConfigurationRequest(_a0 *ecr.PutReplicationConfigurationInput) (*request.Request, *ecr.PutReplicationConfigurationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.PutReplicationConfigurationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.PutReplicationConfigurationOutput
	if rf, ok := ret.Get(1).(func(*ecr.PutReplicationConfigurationInput) *ecr.PutReplicationConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.PutReplicationConfigurationOutput)
		}
	}

	return r0, r1
}

// PutReplicationConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) PutReplicationConfigurationWithContext(_a0 context.Context, _a1 *ecr.PutReplicationConfigurationInput, _a2 ...request.Option) (*ecr.PutReplicationConfigurationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.PutReplicationConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.PutReplicationConfigurationInput, ...request.Option) *ecr.PutReplicationConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutReplicationConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.PutReplicationConfigurationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SetRepositoryPolicy provides a mock function with given fields: _a0
func (_m *MockFakeECR) SetRepositoryPolicy(_a0 *ecr.SetRepositoryPolicyInput) (*ecr.SetRepositoryPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.SetRepositoryPolicyOutput
	if rf, ok := ret.Get(0).(func(*ecr.SetRepositoryPolicyInput) *ecr.SetRepositoryPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.SetRepositoryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.SetRepositoryPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SetRepositoryPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) SetRepositoryPolicyRequest(_a0 *ecr.SetRepositoryPolicyInput) (*request.Request, *ecr.SetRepositoryPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.SetRepositoryPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.SetRepositoryPolicyOutput
	if rf, ok := ret.Get(1).(func(*ecr.SetRepositoryPolicyInput) *ecr.SetRepositoryPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.SetRepositoryPolicyOutput)
		}
	}

	return r0, r1
}

// SetRepositoryPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) SetRepositoryPolicyWithContext(_a0 context.Context, _a1 *ecr.SetRepositoryPolicyInput, _a2 ...request.Option) (*ecr.SetRepositoryPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.SetRepositoryPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.SetRepositoryPolicyInput, ...request.Option) *ecr.SetRepositoryPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.SetRepositoryPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.SetRepositoryPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartImageScan provides a mock function with given fields: _a0
func (_m *MockFakeECR) StartImageScan(_a0 *ecr.StartImageScanInput) (*ecr.StartImageScanOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.StartImageScanOutput
	if rf, ok := ret.Get(0).(func(*ecr.StartImageScanInput) *ecr.StartImageScanOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.StartImageScanOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.StartImageScanInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartImageScanRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) StartImageScanRequest(_a0 *ecr.StartImageScanInput) (*request.Request, *ecr.StartImageScanOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.StartImageScanInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.StartImageScanOutput
	if rf, ok := ret.Get(1).(func(*ecr.StartImageScanInput) *ecr.StartImageScanOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.StartImageScanOutput)
		}
	}

	return r0, r1
}

// StartImageScanWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) StartImageScanWithContext(_a0 context.Context, _a1 *ecr.StartImageScanInput, _a2 ...request.Option) (*ecr.StartImageScanOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.StartImageScanOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.StartImageScanInput, ...request.Option) *ecr.StartImageScanOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.StartImageScanOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.StartImageScanInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartLifecyclePolicyPreview provides a mock function with given fields: _a0
func (_m *MockFakeECR) StartLifecyclePolicyPreview(_a0 *ecr.StartLifecyclePolicyPreviewInput) (*ecr.StartLifecyclePolicyPreviewOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.StartLifecyclePolicyPreviewOutput
	if rf, ok := ret.Get(0).(func(*ecr.StartLifecyclePolicyPreviewInput) *ecr.StartLifecyclePolicyPreviewOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.StartLifecyclePolicyPreviewOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.StartLifecyclePolicyPreviewInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartLifecyclePolicyPreviewRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) StartLifecyclePolicyPreviewRequest(_a0 *ecr.StartLifecyclePolicyPreviewInput) (*request.Request, *ecr.StartLifecyclePolicyPreviewOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.StartLifecyclePolicyPreviewInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.StartLifecyclePolicyPreviewOutput
	if rf, ok := ret.Get(1).(func(*ecr.StartLifecyclePolicyPreviewInput) *ecr.StartLifecyclePolicyPreviewOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.StartLifecyclePolicyPreviewOutput)
		}
	}

	return r0, r1
}

// StartLifecyclePolicyPreviewWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) StartLifecyclePolicyPreviewWithContext(_a0 context.Context, _a1 *ecr.StartLifecyclePolicyPreviewInput, _a2 ...request.Option) (*ecr.StartLifecyclePolicyPreviewOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.StartLifecyclePolicyPreviewOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.StartLifecyclePolicyPreviewInput, ...request.Option) *ecr.StartLifecyclePolicyPreviewOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.StartLifecyclePolicyPreviewOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.StartLifecyclePolicyPreviewInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagResource provides a mock function with given fields: _a0
func (_m *MockFakeECR) TagResource(_a0 *ecr.TagResourceInput) (*ecr.TagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.TagResourceOutput
	if rf, ok := ret.Get(0).(func(*ecr.TagResourceInput) *ecr.TagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.TagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.TagResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) TagResourceRequest(_a0 *ecr.TagResourceInput) (*request.Request, *ecr.TagResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.TagResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.TagResourceOutput
	if rf, ok := ret.Get(1).(func(*ecr.TagResourceInput) *ecr.TagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.TagResourceOutput)
		}
	}

	return r0, r1
}

// TagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) TagResourceWithContext(_a0 context.Context, _a1 *ecr.TagResourceInput, _a2 ...request.Option) (*ecr.TagResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.TagResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.TagResourceInput, ...request.Option) *ecr.TagResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.TagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.TagResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagResource provides a mock function with given fields: _a0
func (_m *MockFakeECR) UntagResource(_a0 *ecr.UntagResourceInput) (*ecr.UntagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(*ecr.UntagResourceInput) *ecr.UntagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.UntagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.UntagResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) UntagResourceRequest(_a0 *ecr.UntagResourceInput) (*request.Request, *ecr.UntagResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.UntagResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.UntagResourceOutput
	if rf, ok := ret.Get(1).(func(*ecr.UntagResourceInput) *ecr.UntagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.UntagResourceOutput)
		}
	}

	return r0, r1
}

// UntagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) UntagResourceWithContext(_a0 context.Context, _a1 *ecr.UntagResourceInput, _a2 ...request.Option) (*ecr.UntagResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.UntagResourceInput, ...request.Option) *ecr.UntagResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.UntagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.UntagResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadLayerPart provides a mock function with given fields: _a0
func (_m *MockFakeECR) UploadLayerPart(_a0 *ecr.UploadLayerPartInput) (*ecr.UploadLayerPartOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ecr.UploadLayerPartOutput
	if rf, ok := ret.Get(0).(func(*ecr.UploadLayerPartInput) *ecr.UploadLayerPartOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.UploadLayerPartOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ecr.UploadLayerPartInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadLayerPartRequest provides a mock function with given fields: _a0
func (_m *MockFakeECR) UploadLayerPartRequest(_a0 *ecr.UploadLayerPartInput) (*request.Request, *ecr.UploadLayerPartOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ecr.UploadLayerPartInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ecr.UploadLayerPartOutput
	if rf, ok := ret.Get(1).(func(*ecr.UploadLayerPartInput) *ecr.UploadLayerPartOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ecr.UploadLayerPartOutput)
		}
	}

	return r0, r1
}

// UploadLayerPartWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) UploadLayerPartWithContext(_a0 context.Context, _a1 *ecr.UploadLayerPartInput, _a2 ...request.Option) (*ecr.UploadLayerPartOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *ecr.UploadLayerPartOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.UploadLayerPartInput, ...request.Option) *ecr.UploadLayerPartOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.UploadLayerPartOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.UploadLayerPartInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilImageScanComplete provides a mock function with given fields: _a0
func (_m *MockFakeECR) WaitUntilImageScanComplete(_a0 *ecr.DescribeImageScanFindingsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecr.DescribeImageScanFindingsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilImageScanCompleteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) WaitUntilImageScanCompleteWithContext(_a0 context.Context, _a1 *ecr.DescribeImageScanFindingsInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeImageScanFindingsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilLifecyclePolicyPreviewComplete provides a mock function with given fields: _a0
func (_m *MockFakeECR) WaitUntilLifecyclePolicyPreviewComplete(_a0 *ecr.GetLifecyclePolicyPreviewInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ecr.GetLifecyclePolicyPreviewInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilLifecyclePolicyPreviewCompleteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeECR) WaitUntilLifecyclePolicyPreviewCompleteWithContext(_a0 context.Context, _a1 *ecr.GetLifecyclePolicyPreviewInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetLifecyclePolicyPreviewInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}