ecrapi.go

// Code generated by mockery v2.12.3. DO NOT EDIT.

package mocks

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"
)

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

// BatchCheckLayerAvailability provides a mock function with given fields: _a0
func (_m *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// BatchGetRepositoryScanningConfiguration provides a mock function with given fields: _a0
func (_m *ECRAPI) BatchGetRepositoryScanningConfiguration(_a0 *ecr.BatchGetRepositoryScanningConfigurationInput) (*ecr.BatchGetRepositoryScanningConfigurationOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// BatchGetRepositoryScanningConfigurationRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) BatchGetRepositoryScanningConfigurationRequest(_a0 *ecr.BatchGetRepositoryScanningConfigurationInput) (*request.Request, *ecr.BatchGetRepositoryScanningConfigurationOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// BatchGetRepositoryScanningConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) BatchGetRepositoryScanningConfigurationWithContext(_a0 context.Context, _a1 *ecr.BatchGetRepositoryScanningConfigurationInput, _a2 ...request.Option) (*ecr.BatchGetRepositoryScanningConfigurationOutput, 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.BatchGetRepositoryScanningConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.BatchGetRepositoryScanningConfigurationInput, ...request.Option) *ecr.BatchGetRepositoryScanningConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.BatchGetRepositoryScanningConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.BatchGetRepositoryScanningConfigurationInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// CreatePullThroughCacheRule provides a mock function with given fields: _a0
func (_m *ECRAPI) CreatePullThroughCacheRule(_a0 *ecr.CreatePullThroughCacheRuleInput) (*ecr.CreatePullThroughCacheRuleOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// CreatePullThroughCacheRuleRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) CreatePullThroughCacheRuleRequest(_a0 *ecr.CreatePullThroughCacheRuleInput) (*request.Request, *ecr.CreatePullThroughCacheRuleOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// CreatePullThroughCacheRuleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) CreatePullThroughCacheRuleWithContext(_a0 context.Context, _a1 *ecr.CreatePullThroughCacheRuleInput, _a2 ...request.Option) (*ecr.CreatePullThroughCacheRuleOutput, 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.CreatePullThroughCacheRuleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.CreatePullThroughCacheRuleInput, ...request.Option) *ecr.CreatePullThroughCacheRuleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.CreatePullThroughCacheRuleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.CreatePullThroughCacheRuleInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// DeletePullThroughCacheRule provides a mock function with given fields: _a0
func (_m *ECRAPI) DeletePullThroughCacheRule(_a0 *ecr.DeletePullThroughCacheRuleInput) (*ecr.DeletePullThroughCacheRuleOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DeletePullThroughCacheRuleRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) DeletePullThroughCacheRuleRequest(_a0 *ecr.DeletePullThroughCacheRuleInput) (*request.Request, *ecr.DeletePullThroughCacheRuleOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DeletePullThroughCacheRuleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) DeletePullThroughCacheRuleWithContext(_a0 context.Context, _a1 *ecr.DeletePullThroughCacheRuleInput, _a2 ...request.Option) (*ecr.DeletePullThroughCacheRuleOutput, 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.DeletePullThroughCacheRuleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DeletePullThroughCacheRuleInput, ...request.Option) *ecr.DeletePullThroughCacheRuleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DeletePullThroughCacheRuleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DeletePullThroughCacheRuleInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// DescribeImageReplicationStatus provides a mock function with given fields: _a0
func (_m *ECRAPI) DescribeImageReplicationStatus(_a0 *ecr.DescribeImageReplicationStatusInput) (*ecr.DescribeImageReplicationStatusOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DescribeImageReplicationStatusRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) DescribeImageReplicationStatusRequest(_a0 *ecr.DescribeImageReplicationStatusInput) (*request.Request, *ecr.DescribeImageReplicationStatusOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DescribeImageReplicationStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) DescribeImageReplicationStatusWithContext(_a0 context.Context, _a1 *ecr.DescribeImageReplicationStatusInput, _a2 ...request.Option) (*ecr.DescribeImageReplicationStatusOutput, 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.DescribeImageReplicationStatusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribeImageReplicationStatusInput, ...request.Option) *ecr.DescribeImageReplicationStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribeImageReplicationStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DescribeImageReplicationStatusInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// DescribePullThroughCacheRules provides a mock function with given fields: _a0
func (_m *ECRAPI) DescribePullThroughCacheRules(_a0 *ecr.DescribePullThroughCacheRulesInput) (*ecr.DescribePullThroughCacheRulesOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DescribePullThroughCacheRulesPages provides a mock function with given fields: _a0, _a1
func (_m *ECRAPI) DescribePullThroughCacheRulesPages(_a0 *ecr.DescribePullThroughCacheRulesInput, _a1 func(*ecr.DescribePullThroughCacheRulesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribePullThroughCacheRulesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ECRAPI) DescribePullThroughCacheRulesPagesWithContext(_a0 context.Context, _a1 *ecr.DescribePullThroughCacheRulesInput, _a2 func(*ecr.DescribePullThroughCacheRulesOutput, 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.DescribePullThroughCacheRulesInput, func(*ecr.DescribePullThroughCacheRulesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribePullThroughCacheRulesRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) DescribePullThroughCacheRulesRequest(_a0 *ecr.DescribePullThroughCacheRulesInput) (*request.Request, *ecr.DescribePullThroughCacheRulesOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DescribePullThroughCacheRulesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) DescribePullThroughCacheRulesWithContext(_a0 context.Context, _a1 *ecr.DescribePullThroughCacheRulesInput, _a2 ...request.Option) (*ecr.DescribePullThroughCacheRulesOutput, 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.DescribePullThroughCacheRulesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.DescribePullThroughCacheRulesInput, ...request.Option) *ecr.DescribePullThroughCacheRulesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.DescribePullThroughCacheRulesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.DescribePullThroughCacheRulesInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// GetRegistryScanningConfiguration provides a mock function with given fields: _a0
func (_m *ECRAPI) GetRegistryScanningConfiguration(_a0 *ecr.GetRegistryScanningConfigurationInput) (*ecr.GetRegistryScanningConfigurationOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// GetRegistryScanningConfigurationRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) GetRegistryScanningConfigurationRequest(_a0 *ecr.GetRegistryScanningConfigurationInput) (*request.Request, *ecr.GetRegistryScanningConfigurationOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// GetRegistryScanningConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) GetRegistryScanningConfigurationWithContext(_a0 context.Context, _a1 *ecr.GetRegistryScanningConfigurationInput, _a2 ...request.Option) (*ecr.GetRegistryScanningConfigurationOutput, 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.GetRegistryScanningConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.GetRegistryScanningConfigurationInput, ...request.Option) *ecr.GetRegistryScanningConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.GetRegistryScanningConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.GetRegistryScanningConfigurationInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// PutRegistryScanningConfiguration provides a mock function with given fields: _a0
func (_m *ECRAPI) PutRegistryScanningConfiguration(_a0 *ecr.PutRegistryScanningConfigurationInput) (*ecr.PutRegistryScanningConfigurationOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// PutRegistryScanningConfigurationRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) PutRegistryScanningConfigurationRequest(_a0 *ecr.PutRegistryScanningConfigurationInput) (*request.Request, *ecr.PutRegistryScanningConfigurationOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// PutRegistryScanningConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) PutRegistryScanningConfigurationWithContext(_a0 context.Context, _a1 *ecr.PutRegistryScanningConfigurationInput, _a2 ...request.Option) (*ecr.PutRegistryScanningConfigurationOutput, 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.PutRegistryScanningConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.PutRegistryScanningConfigurationInput, ...request.Option) *ecr.PutRegistryScanningConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.PutRegistryScanningConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.PutRegistryScanningConfigurationInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// UpdatePullThroughCacheRule provides a mock function with given fields: _a0
func (_m *ECRAPI) UpdatePullThroughCacheRule(_a0 *ecr.UpdatePullThroughCacheRuleInput) (*ecr.UpdatePullThroughCacheRuleOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// UpdatePullThroughCacheRuleRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) UpdatePullThroughCacheRuleRequest(_a0 *ecr.UpdatePullThroughCacheRuleInput) (*request.Request, *ecr.UpdatePullThroughCacheRuleOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// UpdatePullThroughCacheRuleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) UpdatePullThroughCacheRuleWithContext(_a0 context.Context, _a1 *ecr.UpdatePullThroughCacheRuleInput, _a2 ...request.Option) (*ecr.UpdatePullThroughCacheRuleOutput, 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.UpdatePullThroughCacheRuleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.UpdatePullThroughCacheRuleInput, ...request.Option) *ecr.UpdatePullThroughCacheRuleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.UpdatePullThroughCacheRuleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.UpdatePullThroughCacheRuleInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

// ValidatePullThroughCacheRule provides a mock function with given fields: _a0
func (_m *ECRAPI) ValidatePullThroughCacheRule(_a0 *ecr.ValidatePullThroughCacheRuleInput) (*ecr.ValidatePullThroughCacheRuleOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// ValidatePullThroughCacheRuleRequest provides a mock function with given fields: _a0
func (_m *ECRAPI) ValidatePullThroughCacheRuleRequest(_a0 *ecr.ValidatePullThroughCacheRuleInput) (*request.Request, *ecr.ValidatePullThroughCacheRuleOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// ValidatePullThroughCacheRuleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ECRAPI) ValidatePullThroughCacheRuleWithContext(_a0 context.Context, _a1 *ecr.ValidatePullThroughCacheRuleInput, _a2 ...request.Option) (*ecr.ValidatePullThroughCacheRuleOutput, 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.ValidatePullThroughCacheRuleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ecr.ValidatePullThroughCacheRuleInput, ...request.Option) *ecr.ValidatePullThroughCacheRuleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ecr.ValidatePullThroughCacheRuleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ecr.ValidatePullThroughCacheRuleInput, ...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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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 *ECRAPI) 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
}

type NewECRAPIT interface {
	mock.TestingT
	Cleanup(func())
}

// NewECRAPI creates a new instance of ECRAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewECRAPI(t NewECRAPIT) *ECRAPI {
	mock := &ECRAPI{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}