func (m *MockACMAPI) UpdateCertificateOptionsRequest(arg0 *acm.UpdateCertificateOptionsInput) (*request.Request, *acm.UpdateCertificateOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCertificateOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.UpdateCertificateOptionsOutput)
	return ret0, ret1
}
UpdateCertificateOptionsRequest mocks base method
package sdk
import (
	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	acm "github.com/aws/aws-sdk-go/service/acm"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)
type MockACMAPI struct {
	ctrl     *gomock.Controller
	recorder *MockACMAPIMockRecorder
}
type MockACMAPIMockRecorder struct {
	mock *MockACMAPI
}
func NewMockACMAPI(ctrl *gomock.Controller) *MockACMAPI {
	mock := &MockACMAPI{ctrl: ctrl}
	mock.recorder = &MockACMAPIMockRecorder{mock}
	return mock
}
func (m *MockACMAPI) EXPECT() *MockACMAPIMockRecorder {
	return m.recorder
}
func (m *MockACMAPI) AddTagsToCertificate(arg0 *acm.AddTagsToCertificateInput) (*acm.AddTagsToCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTagsToCertificate", arg0)
	ret0, _ := ret[0].(*acm.AddTagsToCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) AddTagsToCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToCertificate", reflect.TypeOf((*MockACMAPI)(nil).AddTagsToCertificate), arg0)
}
func (m *MockACMAPI) AddTagsToCertificateWithContext(arg0 aws.Context, arg1 *acm.AddTagsToCertificateInput, arg2 ...request.Option) (*acm.AddTagsToCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddTagsToCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.AddTagsToCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) AddTagsToCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).AddTagsToCertificateWithContext), varargs...)
}
func (m *MockACMAPI) AddTagsToCertificateRequest(arg0 *acm.AddTagsToCertificateInput) (*request.Request, *acm.AddTagsToCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTagsToCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.AddTagsToCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) AddTagsToCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).AddTagsToCertificateRequest), arg0)
}
func (m *MockACMAPI) DeleteCertificate(arg0 *acm.DeleteCertificateInput) (*acm.DeleteCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCertificate", arg0)
	ret0, _ := ret[0].(*acm.DeleteCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) DeleteCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificate", reflect.TypeOf((*MockACMAPI)(nil).DeleteCertificate), arg0)
}
func (m *MockACMAPI) DeleteCertificateWithContext(arg0 aws.Context, arg1 *acm.DeleteCertificateInput, arg2 ...request.Option) (*acm.DeleteCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.DeleteCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) DeleteCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).DeleteCertificateWithContext), varargs...)
}
func (m *MockACMAPI) DeleteCertificateRequest(arg0 *acm.DeleteCertificateInput) (*request.Request, *acm.DeleteCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.DeleteCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) DeleteCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).DeleteCertificateRequest), arg0)
}
func (m *MockACMAPI) DescribeCertificate(arg0 *acm.DescribeCertificateInput) (*acm.DescribeCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCertificate", arg0)
	ret0, _ := ret[0].(*acm.DescribeCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) DescribeCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificate", reflect.TypeOf((*MockACMAPI)(nil).DescribeCertificate), arg0)
}
func (m *MockACMAPI) DescribeCertificateWithContext(arg0 aws.Context, arg1 *acm.DescribeCertificateInput, arg2 ...request.Option) (*acm.DescribeCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.DescribeCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) DescribeCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).DescribeCertificateWithContext), varargs...)
}
func (m *MockACMAPI) DescribeCertificateRequest(arg0 *acm.DescribeCertificateInput) (*request.Request, *acm.DescribeCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.DescribeCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) DescribeCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).DescribeCertificateRequest), arg0)
}
func (m *MockACMAPI) ExportCertificate(arg0 *acm.ExportCertificateInput) (*acm.ExportCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportCertificate", arg0)
	ret0, _ := ret[0].(*acm.ExportCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ExportCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportCertificate", reflect.TypeOf((*MockACMAPI)(nil).ExportCertificate), arg0)
}
func (m *MockACMAPI) ExportCertificateWithContext(arg0 aws.Context, arg1 *acm.ExportCertificateInput, arg2 ...request.Option) (*acm.ExportCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.ExportCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ExportCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).ExportCertificateWithContext), varargs...)
}
func (m *MockACMAPI) ExportCertificateRequest(arg0 *acm.ExportCertificateInput) (*request.Request, *acm.ExportCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.ExportCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ExportCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).ExportCertificateRequest), arg0)
}
func (m *MockACMAPI) GetCertificate(arg0 *acm.GetCertificateInput) (*acm.GetCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCertificate", arg0)
	ret0, _ := ret[0].(*acm.GetCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) GetCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificate", reflect.TypeOf((*MockACMAPI)(nil).GetCertificate), arg0)
}
func (m *MockACMAPI) GetCertificateWithContext(arg0 aws.Context, arg1 *acm.GetCertificateInput, arg2 ...request.Option) (*acm.GetCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.GetCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) GetCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).GetCertificateWithContext), varargs...)
}
func (m *MockACMAPI) GetCertificateRequest(arg0 *acm.GetCertificateInput) (*request.Request, *acm.GetCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.GetCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) GetCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).GetCertificateRequest), arg0)
}
func (m *MockACMAPI) ImportCertificate(arg0 *acm.ImportCertificateInput) (*acm.ImportCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportCertificate", arg0)
	ret0, _ := ret[0].(*acm.ImportCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ImportCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportCertificate", reflect.TypeOf((*MockACMAPI)(nil).ImportCertificate), arg0)
}
func (m *MockACMAPI) ImportCertificateWithContext(arg0 aws.Context, arg1 *acm.ImportCertificateInput, arg2 ...request.Option) (*acm.ImportCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.ImportCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ImportCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).ImportCertificateWithContext), varargs...)
}
func (m *MockACMAPI) ImportCertificateRequest(arg0 *acm.ImportCertificateInput) (*request.Request, *acm.ImportCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.ImportCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ImportCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).ImportCertificateRequest), arg0)
}
func (m *MockACMAPI) ListCertificates(arg0 *acm.ListCertificatesInput) (*acm.ListCertificatesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCertificates", arg0)
	ret0, _ := ret[0].(*acm.ListCertificatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ListCertificates(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificates", reflect.TypeOf((*MockACMAPI)(nil).ListCertificates), arg0)
}
func (m *MockACMAPI) ListCertificatesWithContext(arg0 aws.Context, arg1 *acm.ListCertificatesInput, arg2 ...request.Option) (*acm.ListCertificatesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCertificatesWithContext", varargs...)
	ret0, _ := ret[0].(*acm.ListCertificatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ListCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificatesWithContext", reflect.TypeOf((*MockACMAPI)(nil).ListCertificatesWithContext), varargs...)
}
func (m *MockACMAPI) ListCertificatesRequest(arg0 *acm.ListCertificatesInput) (*request.Request, *acm.ListCertificatesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCertificatesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.ListCertificatesOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ListCertificatesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificatesRequest", reflect.TypeOf((*MockACMAPI)(nil).ListCertificatesRequest), arg0)
}
func (m *MockACMAPI) ListCertificatesPages(arg0 *acm.ListCertificatesInput, arg1 func(*acm.ListCertificatesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCertificatesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockACMAPIMockRecorder) ListCertificatesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificatesPages", reflect.TypeOf((*MockACMAPI)(nil).ListCertificatesPages), arg0, arg1)
}
func (m *MockACMAPI) ListCertificatesPagesWithContext(arg0 aws.Context, arg1 *acm.ListCertificatesInput, arg2 func(*acm.ListCertificatesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCertificatesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockACMAPIMockRecorder) ListCertificatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificatesPagesWithContext", reflect.TypeOf((*MockACMAPI)(nil).ListCertificatesPagesWithContext), varargs...)
}
func (m *MockACMAPI) ListTagsForCertificate(arg0 *acm.ListTagsForCertificateInput) (*acm.ListTagsForCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForCertificate", arg0)
	ret0, _ := ret[0].(*acm.ListTagsForCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ListTagsForCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForCertificate", reflect.TypeOf((*MockACMAPI)(nil).ListTagsForCertificate), arg0)
}
func (m *MockACMAPI) ListTagsForCertificateWithContext(arg0 aws.Context, arg1 *acm.ListTagsForCertificateInput, arg2 ...request.Option) (*acm.ListTagsForCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsForCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.ListTagsForCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ListTagsForCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).ListTagsForCertificateWithContext), varargs...)
}
func (m *MockACMAPI) ListTagsForCertificateRequest(arg0 *acm.ListTagsForCertificateInput) (*request.Request, *acm.ListTagsForCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.ListTagsForCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ListTagsForCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).ListTagsForCertificateRequest), arg0)
}
func (m *MockACMAPI) RemoveTagsFromCertificate(arg0 *acm.RemoveTagsFromCertificateInput) (*acm.RemoveTagsFromCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTagsFromCertificate", arg0)
	ret0, _ := ret[0].(*acm.RemoveTagsFromCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RemoveTagsFromCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromCertificate", reflect.TypeOf((*MockACMAPI)(nil).RemoveTagsFromCertificate), arg0)
}
func (m *MockACMAPI) RemoveTagsFromCertificateWithContext(arg0 aws.Context, arg1 *acm.RemoveTagsFromCertificateInput, arg2 ...request.Option) (*acm.RemoveTagsFromCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveTagsFromCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.RemoveTagsFromCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RemoveTagsFromCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).RemoveTagsFromCertificateWithContext), varargs...)
}
func (m *MockACMAPI) RemoveTagsFromCertificateRequest(arg0 *acm.RemoveTagsFromCertificateInput) (*request.Request, *acm.RemoveTagsFromCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTagsFromCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.RemoveTagsFromCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RemoveTagsFromCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).RemoveTagsFromCertificateRequest), arg0)
}
func (m *MockACMAPI) RenewCertificate(arg0 *acm.RenewCertificateInput) (*acm.RenewCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenewCertificate", arg0)
	ret0, _ := ret[0].(*acm.RenewCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RenewCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenewCertificate", reflect.TypeOf((*MockACMAPI)(nil).RenewCertificate), arg0)
}
func (m *MockACMAPI) RenewCertificateWithContext(arg0 aws.Context, arg1 *acm.RenewCertificateInput, arg2 ...request.Option) (*acm.RenewCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RenewCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.RenewCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RenewCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenewCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).RenewCertificateWithContext), varargs...)
}
func (m *MockACMAPI) RenewCertificateRequest(arg0 *acm.RenewCertificateInput) (*request.Request, *acm.RenewCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenewCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.RenewCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RenewCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenewCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).RenewCertificateRequest), arg0)
}
func (m *MockACMAPI) RequestCertificate(arg0 *acm.RequestCertificateInput) (*acm.RequestCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestCertificate", arg0)
	ret0, _ := ret[0].(*acm.RequestCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RequestCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCertificate", reflect.TypeOf((*MockACMAPI)(nil).RequestCertificate), arg0)
}
func (m *MockACMAPI) RequestCertificateWithContext(arg0 aws.Context, arg1 *acm.RequestCertificateInput, arg2 ...request.Option) (*acm.RequestCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RequestCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*acm.RequestCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RequestCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).RequestCertificateWithContext), varargs...)
}
func (m *MockACMAPI) RequestCertificateRequest(arg0 *acm.RequestCertificateInput) (*request.Request, *acm.RequestCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.RequestCertificateOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) RequestCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).RequestCertificateRequest), arg0)
}
func (m *MockACMAPI) ResendValidationEmail(arg0 *acm.ResendValidationEmailInput) (*acm.ResendValidationEmailOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResendValidationEmail", arg0)
	ret0, _ := ret[0].(*acm.ResendValidationEmailOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ResendValidationEmail(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendValidationEmail", reflect.TypeOf((*MockACMAPI)(nil).ResendValidationEmail), arg0)
}
func (m *MockACMAPI) ResendValidationEmailWithContext(arg0 aws.Context, arg1 *acm.ResendValidationEmailInput, arg2 ...request.Option) (*acm.ResendValidationEmailOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResendValidationEmailWithContext", varargs...)
	ret0, _ := ret[0].(*acm.ResendValidationEmailOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ResendValidationEmailWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendValidationEmailWithContext", reflect.TypeOf((*MockACMAPI)(nil).ResendValidationEmailWithContext), varargs...)
}
func (m *MockACMAPI) ResendValidationEmailRequest(arg0 *acm.ResendValidationEmailInput) (*request.Request, *acm.ResendValidationEmailOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResendValidationEmailRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*acm.ResendValidationEmailOutput)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) ResendValidationEmailRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendValidationEmailRequest", reflect.TypeOf((*MockACMAPI)(nil).ResendValidationEmailRequest), arg0)
}
func (m *MockACMAPI) UpdateCertificateOptions(arg0 *acm.UpdateCertificateOptionsInput) (*acm.UpdateCertificateOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCertificateOptions", arg0)
	ret0, _ := ret[0].(*acm.UpdateCertificateOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) UpdateCertificateOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCertificateOptions", reflect.TypeOf((*MockACMAPI)(nil).UpdateCertificateOptions), arg0)
}
func (m *MockACMAPI) UpdateCertificateOptionsWithContext(arg0 aws.Context, arg1 *acm.UpdateCertificateOptionsInput, arg2 ...request.Option) (*acm.UpdateCertificateOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateCertificateOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*acm.UpdateCertificateOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockACMAPIMockRecorder) UpdateCertificateOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCertificateOptionsWithContext", reflect.TypeOf((*MockACMAPI)(nil).UpdateCertificateOptionsWithContext), varargs...)
}