func (m *MockConfig) KeyStorePath() string {
	ret := m.ctrl.Call(m, "KeyStorePath")
	ret0, _ := ret[0].(string)
	return ret0
}
KeyStorePath mocks base method
package mock_apiconfig
import (
	tls "crypto/tls"
	x509 "crypto/x509"
	reflect "reflect"
	time "time"
	gomock "github.com/golang/mock/gomock"
	apiconfig "github.com/hyperledger/fabric-sdk-go/api/apiconfig"
)
type MockConfig struct {
	ctrl     *gomock.Controller
	recorder *MockConfigMockRecorder
}
type MockConfigMockRecorder struct {
	mock *MockConfig
}
func NewMockConfig(ctrl *gomock.Controller) *MockConfig {
	mock := &MockConfig{ctrl: ctrl}
	mock.recorder = &MockConfigMockRecorder{mock}
	return mock
}
func (m *MockConfig) EXPECT() *MockConfigMockRecorder {
	return m.recorder
}
func (m *MockConfig) CAClientCertPath(arg0 string) (string, error) {
	ret := m.ctrl.Call(m, "CAClientCertPath", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) CAClientCertPath(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CAClientCertPath", reflect.TypeOf((*MockConfig)(nil).CAClientCertPath), arg0)
}
func (m *MockConfig) CAClientCertPem(arg0 string) (string, error) {
	ret := m.ctrl.Call(m, "CAClientCertPem", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) CAClientCertPem(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CAClientCertPem", reflect.TypeOf((*MockConfig)(nil).CAClientCertPem), arg0)
}
func (m *MockConfig) CAClientKeyPath(arg0 string) (string, error) {
	ret := m.ctrl.Call(m, "CAClientKeyPath", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) CAClientKeyPath(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CAClientKeyPath", reflect.TypeOf((*MockConfig)(nil).CAClientKeyPath), arg0)
}
func (m *MockConfig) CAClientKeyPem(arg0 string) (string, error) {
	ret := m.ctrl.Call(m, "CAClientKeyPem", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) CAClientKeyPem(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CAClientKeyPem", reflect.TypeOf((*MockConfig)(nil).CAClientKeyPem), arg0)
}
func (m *MockConfig) CAConfig(arg0 string) (*apiconfig.CAConfig, error) {
	ret := m.ctrl.Call(m, "CAConfig", arg0)
	ret0, _ := ret[0].(*apiconfig.CAConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) CAConfig(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CAConfig", reflect.TypeOf((*MockConfig)(nil).CAConfig), arg0)
}
func (m *MockConfig) CAKeyStorePath() string {
	ret := m.ctrl.Call(m, "CAKeyStorePath")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockConfigMockRecorder) CAKeyStorePath() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CAKeyStorePath", reflect.TypeOf((*MockConfig)(nil).CAKeyStorePath))
}
func (m *MockConfig) CAServerCertPaths(arg0 string) ([]string, error) {
	ret := m.ctrl.Call(m, "CAServerCertPaths", arg0)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) CAServerCertPaths(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CAServerCertPaths", reflect.TypeOf((*MockConfig)(nil).CAServerCertPaths), arg0)
}
func (m *MockConfig) CAServerCertPems(arg0 string) ([]string, error) {
	ret := m.ctrl.Call(m, "CAServerCertPems", arg0)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) CAServerCertPems(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CAServerCertPems", reflect.TypeOf((*MockConfig)(nil).CAServerCertPems), arg0)
}
func (m *MockConfig) ChannelConfig(arg0 string) (*apiconfig.ChannelConfig, error) {
	ret := m.ctrl.Call(m, "ChannelConfig", arg0)
	ret0, _ := ret[0].(*apiconfig.ChannelConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) ChannelConfig(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChannelConfig", reflect.TypeOf((*MockConfig)(nil).ChannelConfig), arg0)
}
func (m *MockConfig) ChannelOrderers(arg0 string) ([]apiconfig.OrdererConfig, error) {
	ret := m.ctrl.Call(m, "ChannelOrderers", arg0)
	ret0, _ := ret[0].([]apiconfig.OrdererConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) ChannelOrderers(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChannelOrderers", reflect.TypeOf((*MockConfig)(nil).ChannelOrderers), arg0)
}
func (m *MockConfig) ChannelPeers(arg0 string) ([]apiconfig.ChannelPeer, error) {
	ret := m.ctrl.Call(m, "ChannelPeers", arg0)
	ret0, _ := ret[0].([]apiconfig.ChannelPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) ChannelPeers(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChannelPeers", reflect.TypeOf((*MockConfig)(nil).ChannelPeers), arg0)
}
func (m *MockConfig) Client() (*apiconfig.ClientConfig, error) {
	ret := m.ctrl.Call(m, "Client")
	ret0, _ := ret[0].(*apiconfig.ClientConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockConfigMockRecorder) Client() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Client", reflect.TypeOf((*MockConfig)(nil).Client))
}
func (m *MockConfig) CryptoConfigPath() string {
	ret := m.ctrl.Call(m, "CryptoConfigPath")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockConfigMockRecorder) CryptoConfigPath() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CryptoConfigPath", reflect.TypeOf((*MockConfig)(nil).CryptoConfigPath))
}
func (m *MockConfig) Ephemeral() bool {
	ret := m.ctrl.Call(m, "Ephemeral")
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockConfigMockRecorder) Ephemeral() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ephemeral", reflect.TypeOf((*MockConfig)(nil).Ephemeral))
}
func (m *MockConfig) IsSecurityEnabled() bool {
	ret := m.ctrl.Call(m, "IsSecurityEnabled")
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockConfigMockRecorder) IsSecurityEnabled() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSecurityEnabled", reflect.TypeOf((*MockConfig)(nil).IsSecurityEnabled))
}