// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify
// Copyright (c) Abstract Machines
// SPDX-License-Identifier: Apache-2.0

package mocks

import (
	"github.com/absmach/certs"
	"github.com/absmach/certs/sdk"
	"github.com/absmach/supermq/pkg/errors"
	mock "github.com/stretchr/testify/mock"
)

// NewSDK creates a new instance of SDK. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewSDK(t interface {
	mock.TestingT
	Cleanup(func())
}) *SDK {
	mock := &SDK{}
	mock.Mock.Test(t)

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

	return mock
}

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

type SDK_Expecter struct {
	mock *mock.Mock
}

func (_m *SDK) EXPECT() *SDK_Expecter {
	return &SDK_Expecter{mock: &_m.Mock}
}

// CreateCSR provides a mock function for the type SDK
func (_mock *SDK) CreateCSR(metadata certs.CSRMetadata, privKey any) (certs.CSR, errors.SDKError) {
	ret := _mock.Called(metadata, privKey)

	if len(ret) == 0 {
		panic("no return value specified for CreateCSR")
	}

	var r0 certs.CSR
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(certs.CSRMetadata, any) (certs.CSR, errors.SDKError)); ok {
		return returnFunc(metadata, privKey)
	}
	if returnFunc, ok := ret.Get(0).(func(certs.CSRMetadata, any) certs.CSR); ok {
		r0 = returnFunc(metadata, privKey)
	} else {
		r0 = ret.Get(0).(certs.CSR)
	}
	if returnFunc, ok := ret.Get(1).(func(certs.CSRMetadata, any) errors.SDKError); ok {
		r1 = returnFunc(metadata, privKey)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_CreateCSR_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCSR'
type SDK_CreateCSR_Call struct {
	*mock.Call
}

// CreateCSR is a helper method to define mock.On call
//   - metadata certs.CSRMetadata
//   - privKey any
func (_e *SDK_Expecter) CreateCSR(metadata interface{}, privKey interface{}) *SDK_CreateCSR_Call {
	return &SDK_CreateCSR_Call{Call: _e.mock.On("CreateCSR", metadata, privKey)}
}

func (_c *SDK_CreateCSR_Call) Run(run func(metadata certs.CSRMetadata, privKey any)) *SDK_CreateCSR_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 certs.CSRMetadata
		if args[0] != nil {
			arg0 = args[0].(certs.CSRMetadata)
		}
		var arg1 any
		if args[1] != nil {
			arg1 = args[1].(any)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_CreateCSR_Call) Return(cSR certs.CSR, sDKError errors.SDKError) *SDK_CreateCSR_Call {
	_c.Call.Return(cSR, sDKError)
	return _c
}

func (_c *SDK_CreateCSR_Call) RunAndReturn(run func(metadata certs.CSRMetadata, privKey any) (certs.CSR, errors.SDKError)) *SDK_CreateCSR_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteCert provides a mock function for the type SDK
func (_mock *SDK) DeleteCert(entityID string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(entityID, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for DeleteCert")
	}

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok {
		r0 = returnFunc(entityID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

// SDK_DeleteCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCert'
type SDK_DeleteCert_Call struct {
	*mock.Call
}

// DeleteCert is a helper method to define mock.On call
//   - entityID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DeleteCert(entityID interface{}, domainID interface{}, token interface{}) *SDK_DeleteCert_Call {
	return &SDK_DeleteCert_Call{Call: _e.mock.On("DeleteCert", entityID, domainID, token)}
}

func (_c *SDK_DeleteCert_Call) Run(run func(entityID string, domainID string, token string)) *SDK_DeleteCert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_DeleteCert_Call) Return(sDKError errors.SDKError) *SDK_DeleteCert_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteCert_Call) RunAndReturn(run func(entityID string, domainID string, token string) errors.SDKError) *SDK_DeleteCert_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadCA provides a mock function for the type SDK
func (_mock *SDK) DownloadCA() (sdk.CertificateBundle, errors.SDKError) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for DownloadCA")
	}

	var r0 sdk.CertificateBundle
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func() (sdk.CertificateBundle, errors.SDKError)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() sdk.CertificateBundle); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(sdk.CertificateBundle)
	}
	if returnFunc, ok := ret.Get(1).(func() errors.SDKError); ok {
		r1 = returnFunc()
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_DownloadCA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadCA'
type SDK_DownloadCA_Call struct {
	*mock.Call
}

// DownloadCA is a helper method to define mock.On call
func (_e *SDK_Expecter) DownloadCA() *SDK_DownloadCA_Call {
	return &SDK_DownloadCA_Call{Call: _e.mock.On("DownloadCA")}
}

func (_c *SDK_DownloadCA_Call) Run(run func()) *SDK_DownloadCA_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *SDK_DownloadCA_Call) Return(certificateBundle sdk.CertificateBundle, sDKError errors.SDKError) *SDK_DownloadCA_Call {
	_c.Call.Return(certificateBundle, sDKError)
	return _c
}

func (_c *SDK_DownloadCA_Call) RunAndReturn(run func() (sdk.CertificateBundle, errors.SDKError)) *SDK_DownloadCA_Call {
	_c.Call.Return(run)
	return _c
}

// GenerateCRL provides a mock function for the type SDK
func (_mock *SDK) GenerateCRL() ([]byte, errors.SDKError) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GenerateCRL")
	}

	var r0 []byte
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func() ([]byte, errors.SDKError)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []byte); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() errors.SDKError); ok {
		r1 = returnFunc()
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_GenerateCRL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenerateCRL'
type SDK_GenerateCRL_Call struct {
	*mock.Call
}

// GenerateCRL is a helper method to define mock.On call
func (_e *SDK_Expecter) GenerateCRL() *SDK_GenerateCRL_Call {
	return &SDK_GenerateCRL_Call{Call: _e.mock.On("GenerateCRL")}
}

func (_c *SDK_GenerateCRL_Call) Run(run func()) *SDK_GenerateCRL_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *SDK_GenerateCRL_Call) Return(bytes []byte, sDKError errors.SDKError) *SDK_GenerateCRL_Call {
	_c.Call.Return(bytes, sDKError)
	return _c
}

func (_c *SDK_GenerateCRL_Call) RunAndReturn(run func() ([]byte, errors.SDKError)) *SDK_GenerateCRL_Call {
	_c.Call.Return(run)
	return _c
}

// GetEntityID provides a mock function for the type SDK
func (_mock *SDK) GetEntityID(serialNumber string, domainID string, token string) (string, errors.SDKError) {
	ret := _mock.Called(serialNumber, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for GetEntityID")
	}

	var r0 string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, string) (string, errors.SDKError)); ok {
		return returnFunc(serialNumber, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, string) string); ok {
		r0 = returnFunc(serialNumber, domainID, token)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok {
		r1 = returnFunc(serialNumber, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_GetEntityID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEntityID'
type SDK_GetEntityID_Call struct {
	*mock.Call
}

// GetEntityID is a helper method to define mock.On call
//   - serialNumber string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) GetEntityID(serialNumber interface{}, domainID interface{}, token interface{}) *SDK_GetEntityID_Call {
	return &SDK_GetEntityID_Call{Call: _e.mock.On("GetEntityID", serialNumber, domainID, token)}
}

func (_c *SDK_GetEntityID_Call) Run(run func(serialNumber string, domainID string, token string)) *SDK_GetEntityID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_GetEntityID_Call) Return(s string, sDKError errors.SDKError) *SDK_GetEntityID_Call {
	_c.Call.Return(s, sDKError)
	return _c
}

func (_c *SDK_GetEntityID_Call) RunAndReturn(run func(serialNumber string, domainID string, token string) (string, errors.SDKError)) *SDK_GetEntityID_Call {
	_c.Call.Return(run)
	return _c
}

// IssueCert provides a mock function for the type SDK
func (_mock *SDK) IssueCert(entityID string, ttl string, ipAddrs []string, opts sdk.Options, domainID string, token string) (sdk.Certificate, errors.SDKError) {
	ret := _mock.Called(entityID, ttl, ipAddrs, opts, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for IssueCert")
	}

	var r0 sdk.Certificate
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, []string, sdk.Options, string, string) (sdk.Certificate, errors.SDKError)); ok {
		return returnFunc(entityID, ttl, ipAddrs, opts, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, []string, sdk.Options, string, string) sdk.Certificate); ok {
		r0 = returnFunc(entityID, ttl, ipAddrs, opts, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Certificate)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, []string, sdk.Options, string, string) errors.SDKError); ok {
		r1 = returnFunc(entityID, ttl, ipAddrs, opts, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_IssueCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueCert'
type SDK_IssueCert_Call struct {
	*mock.Call
}

// IssueCert is a helper method to define mock.On call
//   - entityID string
//   - ttl string
//   - ipAddrs []string
//   - opts sdk.Options
//   - domainID string
//   - token string
func (_e *SDK_Expecter) IssueCert(entityID interface{}, ttl interface{}, ipAddrs interface{}, opts interface{}, domainID interface{}, token interface{}) *SDK_IssueCert_Call {
	return &SDK_IssueCert_Call{Call: _e.mock.On("IssueCert", entityID, ttl, ipAddrs, opts, domainID, token)}
}

func (_c *SDK_IssueCert_Call) Run(run func(entityID string, ttl string, ipAddrs []string, opts sdk.Options, domainID string, token string)) *SDK_IssueCert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		var arg3 sdk.Options
		if args[3] != nil {
			arg3 = args[3].(sdk.Options)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_IssueCert_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_IssueCert_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_IssueCert_Call) RunAndReturn(run func(entityID string, ttl string, ipAddrs []string, opts sdk.Options, domainID string, token string) (sdk.Certificate, errors.SDKError)) *SDK_IssueCert_Call {
	_c.Call.Return(run)
	return _c
}

// IssueFromCSR provides a mock function for the type SDK
func (_mock *SDK) IssueFromCSR(entityID string, ttl string, csr string, domainID string, token string) (sdk.Certificate, errors.SDKError) {
	ret := _mock.Called(entityID, ttl, csr, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for IssueFromCSR")
	}

	var r0 sdk.Certificate
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, string, string, string) (sdk.Certificate, errors.SDKError)); ok {
		return returnFunc(entityID, ttl, csr, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, string, string, string) sdk.Certificate); ok {
		r0 = returnFunc(entityID, ttl, csr, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Certificate)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(entityID, ttl, csr, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_IssueFromCSR_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueFromCSR'
type SDK_IssueFromCSR_Call struct {
	*mock.Call
}

// IssueFromCSR is a helper method to define mock.On call
//   - entityID string
//   - ttl string
//   - csr string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) IssueFromCSR(entityID interface{}, ttl interface{}, csr interface{}, domainID interface{}, token interface{}) *SDK_IssueFromCSR_Call {
	return &SDK_IssueFromCSR_Call{Call: _e.mock.On("IssueFromCSR", entityID, ttl, csr, domainID, token)}
}

func (_c *SDK_IssueFromCSR_Call) Run(run func(entityID string, ttl string, csr string, domainID string, token string)) *SDK_IssueFromCSR_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_IssueFromCSR_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_IssueFromCSR_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_IssueFromCSR_Call) RunAndReturn(run func(entityID string, ttl string, csr string, domainID string, token string) (sdk.Certificate, errors.SDKError)) *SDK_IssueFromCSR_Call {
	_c.Call.Return(run)
	return _c
}

// IssueFromCSRInternal provides a mock function for the type SDK
func (_mock *SDK) IssueFromCSRInternal(entityID string, ttl string, csr string, token string) (sdk.Certificate, errors.SDKError) {
	ret := _mock.Called(entityID, ttl, csr, token)

	if len(ret) == 0 {
		panic("no return value specified for IssueFromCSRInternal")
	}

	var r0 sdk.Certificate
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, string, string) (sdk.Certificate, errors.SDKError)); ok {
		return returnFunc(entityID, ttl, csr, token)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, string, string) sdk.Certificate); ok {
		r0 = returnFunc(entityID, ttl, csr, token)
	} else {
		r0 = ret.Get(0).(sdk.Certificate)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(entityID, ttl, csr, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_IssueFromCSRInternal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueFromCSRInternal'
type SDK_IssueFromCSRInternal_Call struct {
	*mock.Call
}

// IssueFromCSRInternal is a helper method to define mock.On call
//   - entityID string
//   - ttl string
//   - csr string
//   - token string
func (_e *SDK_Expecter) IssueFromCSRInternal(entityID interface{}, ttl interface{}, csr interface{}, token interface{}) *SDK_IssueFromCSRInternal_Call {
	return &SDK_IssueFromCSRInternal_Call{Call: _e.mock.On("IssueFromCSRInternal", entityID, ttl, csr, token)}
}

func (_c *SDK_IssueFromCSRInternal_Call) Run(run func(entityID string, ttl string, csr string, token string)) *SDK_IssueFromCSRInternal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_IssueFromCSRInternal_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_IssueFromCSRInternal_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_IssueFromCSRInternal_Call) RunAndReturn(run func(entityID string, ttl string, csr string, token string) (sdk.Certificate, errors.SDKError)) *SDK_IssueFromCSRInternal_Call {
	_c.Call.Return(run)
	return _c
}

// ListCerts provides a mock function for the type SDK
func (_mock *SDK) ListCerts(pm sdk.PageMetadata, domainID string, token string) (sdk.CertificatePage, errors.SDKError) {
	ret := _mock.Called(pm, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for ListCerts")
	}

	var r0 sdk.CertificatePage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.CertificatePage, errors.SDKError)); ok {
		return returnFunc(pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.CertificatePage); ok {
		r0 = returnFunc(pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.CertificatePage)
	}
	if returnFunc, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok {
		r1 = returnFunc(pm, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_ListCerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCerts'
type SDK_ListCerts_Call struct {
	*mock.Call
}

// ListCerts is a helper method to define mock.On call
//   - pm sdk.PageMetadata
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ListCerts(pm interface{}, domainID interface{}, token interface{}) *SDK_ListCerts_Call {
	return &SDK_ListCerts_Call{Call: _e.mock.On("ListCerts", pm, domainID, token)}
}

func (_c *SDK_ListCerts_Call) Run(run func(pm sdk.PageMetadata, domainID string, token string)) *SDK_ListCerts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 sdk.PageMetadata
		if args[0] != nil {
			arg0 = args[0].(sdk.PageMetadata)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_ListCerts_Call) Return(certificatePage sdk.CertificatePage, sDKError errors.SDKError) *SDK_ListCerts_Call {
	_c.Call.Return(certificatePage, sDKError)
	return _c
}

func (_c *SDK_ListCerts_Call) RunAndReturn(run func(pm sdk.PageMetadata, domainID string, token string) (sdk.CertificatePage, errors.SDKError)) *SDK_ListCerts_Call {
	_c.Call.Return(run)
	return _c
}

// OCSP provides a mock function for the type SDK
func (_mock *SDK) OCSP(serialNumber string, cert string) (sdk.OCSPResponse, errors.SDKError) {
	ret := _mock.Called(serialNumber, cert)

	if len(ret) == 0 {
		panic("no return value specified for OCSP")
	}

	var r0 sdk.OCSPResponse
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string) (sdk.OCSPResponse, errors.SDKError)); ok {
		return returnFunc(serialNumber, cert)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string) sdk.OCSPResponse); ok {
		r0 = returnFunc(serialNumber, cert)
	} else {
		r0 = ret.Get(0).(sdk.OCSPResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string) errors.SDKError); ok {
		r1 = returnFunc(serialNumber, cert)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_OCSP_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OCSP'
type SDK_OCSP_Call struct {
	*mock.Call
}

// OCSP is a helper method to define mock.On call
//   - serialNumber string
//   - cert string
func (_e *SDK_Expecter) OCSP(serialNumber interface{}, cert interface{}) *SDK_OCSP_Call {
	return &SDK_OCSP_Call{Call: _e.mock.On("OCSP", serialNumber, cert)}
}

func (_c *SDK_OCSP_Call) Run(run func(serialNumber string, cert string)) *SDK_OCSP_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_OCSP_Call) Return(oCSPResponse sdk.OCSPResponse, sDKError errors.SDKError) *SDK_OCSP_Call {
	_c.Call.Return(oCSPResponse, sDKError)
	return _c
}

func (_c *SDK_OCSP_Call) RunAndReturn(run func(serialNumber string, cert string) (sdk.OCSPResponse, errors.SDKError)) *SDK_OCSP_Call {
	_c.Call.Return(run)
	return _c
}

// RenewCert provides a mock function for the type SDK
func (_mock *SDK) RenewCert(serialNumber string, domainID string, token string) (sdk.Certificate, errors.SDKError) {
	ret := _mock.Called(serialNumber, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for RenewCert")
	}

	var r0 sdk.Certificate
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, string) (sdk.Certificate, errors.SDKError)); ok {
		return returnFunc(serialNumber, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, string) sdk.Certificate); ok {
		r0 = returnFunc(serialNumber, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Certificate)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok {
		r1 = returnFunc(serialNumber, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_RenewCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenewCert'
type SDK_RenewCert_Call struct {
	*mock.Call
}

// RenewCert is a helper method to define mock.On call
//   - serialNumber string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RenewCert(serialNumber interface{}, domainID interface{}, token interface{}) *SDK_RenewCert_Call {
	return &SDK_RenewCert_Call{Call: _e.mock.On("RenewCert", serialNumber, domainID, token)}
}

func (_c *SDK_RenewCert_Call) Run(run func(serialNumber string, domainID string, token string)) *SDK_RenewCert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_RenewCert_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_RenewCert_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_RenewCert_Call) RunAndReturn(run func(serialNumber string, domainID string, token string) (sdk.Certificate, errors.SDKError)) *SDK_RenewCert_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeAll provides a mock function for the type SDK
func (_mock *SDK) RevokeAll(entityID string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(entityID, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for RevokeAll")
	}

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok {
		r0 = returnFunc(entityID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

// SDK_RevokeAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeAll'
type SDK_RevokeAll_Call struct {
	*mock.Call
}

// RevokeAll is a helper method to define mock.On call
//   - entityID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RevokeAll(entityID interface{}, domainID interface{}, token interface{}) *SDK_RevokeAll_Call {
	return &SDK_RevokeAll_Call{Call: _e.mock.On("RevokeAll", entityID, domainID, token)}
}

func (_c *SDK_RevokeAll_Call) Run(run func(entityID string, domainID string, token string)) *SDK_RevokeAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_RevokeAll_Call) Return(sDKError errors.SDKError) *SDK_RevokeAll_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RevokeAll_Call) RunAndReturn(run func(entityID string, domainID string, token string) errors.SDKError) *SDK_RevokeAll_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeCert provides a mock function for the type SDK
func (_mock *SDK) RevokeCert(serialNumber string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(serialNumber, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for RevokeCert")
	}

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok {
		r0 = returnFunc(serialNumber, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

// SDK_RevokeCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeCert'
type SDK_RevokeCert_Call struct {
	*mock.Call
}

// RevokeCert is a helper method to define mock.On call
//   - serialNumber string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RevokeCert(serialNumber interface{}, domainID interface{}, token interface{}) *SDK_RevokeCert_Call {
	return &SDK_RevokeCert_Call{Call: _e.mock.On("RevokeCert", serialNumber, domainID, token)}
}

func (_c *SDK_RevokeCert_Call) Run(run func(serialNumber string, domainID string, token string)) *SDK_RevokeCert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_RevokeCert_Call) Return(sDKError errors.SDKError) *SDK_RevokeCert_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RevokeCert_Call) RunAndReturn(run func(serialNumber string, domainID string, token string) errors.SDKError) *SDK_RevokeCert_Call {
	_c.Call.Return(run)
	return _c
}

// ViewCA provides a mock function for the type SDK
func (_mock *SDK) ViewCA() (sdk.Certificate, errors.SDKError) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for ViewCA")
	}

	var r0 sdk.Certificate
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func() (sdk.Certificate, errors.SDKError)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() sdk.Certificate); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(sdk.Certificate)
	}
	if returnFunc, ok := ret.Get(1).(func() errors.SDKError); ok {
		r1 = returnFunc()
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_ViewCA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewCA'
type SDK_ViewCA_Call struct {
	*mock.Call
}

// ViewCA is a helper method to define mock.On call
func (_e *SDK_Expecter) ViewCA() *SDK_ViewCA_Call {
	return &SDK_ViewCA_Call{Call: _e.mock.On("ViewCA")}
}

func (_c *SDK_ViewCA_Call) Run(run func()) *SDK_ViewCA_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *SDK_ViewCA_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_ViewCA_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_ViewCA_Call) RunAndReturn(run func() (sdk.Certificate, errors.SDKError)) *SDK_ViewCA_Call {
	_c.Call.Return(run)
	return _c
}

// ViewCert provides a mock function for the type SDK
func (_mock *SDK) ViewCert(serialNumber string, domainID string, token string) (sdk.Certificate, errors.SDKError) {
	ret := _mock.Called(serialNumber, domainID, token)

	if len(ret) == 0 {
		panic("no return value specified for ViewCert")
	}

	var r0 sdk.Certificate
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string, string, string) (sdk.Certificate, errors.SDKError)); ok {
		return returnFunc(serialNumber, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string, string) sdk.Certificate); ok {
		r0 = returnFunc(serialNumber, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Certificate)
	}
	if returnFunc, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok {
		r1 = returnFunc(serialNumber, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// SDK_ViewCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewCert'
type SDK_ViewCert_Call struct {
	*mock.Call
}

// ViewCert is a helper method to define mock.On call
//   - serialNumber string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ViewCert(serialNumber interface{}, domainID interface{}, token interface{}) *SDK_ViewCert_Call {
	return &SDK_ViewCert_Call{Call: _e.mock.On("ViewCert", serialNumber, domainID, token)}
}

func (_c *SDK_ViewCert_Call) Run(run func(serialNumber string, domainID string, token string)) *SDK_ViewCert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_ViewCert_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_ViewCert_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_ViewCert_Call) RunAndReturn(run func(serialNumber string, domainID string, token string) (sdk.Certificate, errors.SDKError)) *SDK_ViewCert_Call {
	_c.Call.Return(run)
	return _c
}
