// Code generated by MockGen. DO NOT EDIT.
// Source: interface.go
//
// Generated by this command:
//
//	mockgen -source interface.go -destination ../internal/testmocks/config/config_mock.go -package config -typed
//

// Package config is a generated GoMock package.
package config

import (
	reflect "reflect"

	config "codeberg.org/danjones000/combluotion/config"
	gomock "go.uber.org/mock/gomock"
)

// MockConfig is a mock of Config interface.
type MockConfig struct {
	ctrl     *gomock.Controller
	recorder *MockConfigMockRecorder
	isgomock struct{}
}

// MockConfigMockRecorder is the mock recorder for MockConfig.
type MockConfigMockRecorder struct {
	mock *MockConfig
}

// NewMockConfig creates a new mock instance.
func NewMockConfig(ctrl *gomock.Controller) *MockConfig {
	mock := &MockConfig{ctrl: ctrl}
	mock.recorder = &MockConfigMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockConfig) EXPECT() *MockConfigMockRecorder {
	return m.recorder
}

// BaseURL mocks base method.
func (m *MockConfig) BaseURL() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BaseURL")
	ret0, _ := ret[0].(string)
	return ret0
}

// BaseURL indicates an expected call of BaseURL.
func (mr *MockConfigMockRecorder) BaseURL() *MockConfigBaseURLCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BaseURL", reflect.TypeOf((*MockConfig)(nil).BaseURL))
	return &MockConfigBaseURLCall{Call: call}
}

// MockConfigBaseURLCall wrap *gomock.Call
type MockConfigBaseURLCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockConfigBaseURLCall) Return(arg0 string) *MockConfigBaseURLCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockConfigBaseURLCall) Do(f func() string) *MockConfigBaseURLCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConfigBaseURLCall) DoAndReturn(f func() string) *MockConfigBaseURLCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Env mocks base method.
func (m *MockConfig) Env() config.Env {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Env")
	ret0, _ := ret[0].(config.Env)
	return ret0
}

// Env indicates an expected call of Env.
func (mr *MockConfigMockRecorder) Env() *MockConfigEnvCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Env", reflect.TypeOf((*MockConfig)(nil).Env))
	return &MockConfigEnvCall{Call: call}
}

// MockConfigEnvCall wrap *gomock.Call
type MockConfigEnvCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockConfigEnvCall) Return(arg0 config.Env) *MockConfigEnvCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockConfigEnvCall) Do(f func() config.Env) *MockConfigEnvCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConfigEnvCall) DoAndReturn(f func() config.Env) *MockConfigEnvCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Name mocks base method.
func (m *MockConfig) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockConfigMockRecorder) Name() *MockConfigNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockConfig)(nil).Name))
	return &MockConfigNameCall{Call: call}
}

// MockConfigNameCall wrap *gomock.Call
type MockConfigNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockConfigNameCall) Return(arg0 string) *MockConfigNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockConfigNameCall) Do(f func() string) *MockConfigNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConfigNameCall) DoAndReturn(f func() string) *MockConfigNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Store mocks base method.
func (m *MockConfig) Store(name string) (config.Store, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Store", name)
	ret0, _ := ret[0].(config.Store)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Store indicates an expected call of Store.
func (mr *MockConfigMockRecorder) Store(name any) *MockConfigStoreCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Store", reflect.TypeOf((*MockConfig)(nil).Store), name)
	return &MockConfigStoreCall{Call: call}
}

// MockConfigStoreCall wrap *gomock.Call
type MockConfigStoreCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockConfigStoreCall) Return(arg0 config.Store, arg1 error) *MockConfigStoreCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockConfigStoreCall) Do(f func(string) (config.Store, error)) *MockConfigStoreCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConfigStoreCall) DoAndReturn(f func(string) (config.Store, error)) *MockConfigStoreCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StoreName mocks base method.
func (m *MockConfig) StoreName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StoreName")
	ret0, _ := ret[0].(string)
	return ret0
}

// StoreName indicates an expected call of StoreName.
func (mr *MockConfigMockRecorder) StoreName() *MockConfigStoreNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreName", reflect.TypeOf((*MockConfig)(nil).StoreName))
	return &MockConfigStoreNameCall{Call: call}
}

// MockConfigStoreNameCall wrap *gomock.Call
type MockConfigStoreNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockConfigStoreNameCall) Return(arg0 string) *MockConfigStoreNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockConfigStoreNameCall) Do(f func() string) *MockConfigStoreNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockConfigStoreNameCall) DoAndReturn(f func() string) *MockConfigStoreNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStore) EXPECT() *MockStoreMockRecorder {
	return m.recorder
}

// Decode mocks base method.
func (m *MockStore) Decode(v any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Decode", v)
	ret0, _ := ret[0].(error)
	return ret0
}

// Decode indicates an expected call of Decode.
func (mr *MockStoreMockRecorder) Decode(v any) *MockStoreDecodeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockStore)(nil).Decode), v)
	return &MockStoreDecodeCall{Call: call}
}

// MockStoreDecodeCall wrap *gomock.Call
type MockStoreDecodeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreDecodeCall) Return(arg0 error) *MockStoreDecodeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreDecodeCall) Do(f func(any) error) *MockStoreDecodeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreDecodeCall) DoAndReturn(f func(any) error) *MockStoreDecodeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Map mocks base method.
func (m *MockStore) Map() (map[string]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Map")
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Map indicates an expected call of Map.
func (mr *MockStoreMockRecorder) Map() *MockStoreMapCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Map", reflect.TypeOf((*MockStore)(nil).Map))
	return &MockStoreMapCall{Call: call}
}

// MockStoreMapCall wrap *gomock.Call
type MockStoreMapCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreMapCall) Return(arg0 map[string]any, arg1 error) *MockStoreMapCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreMapCall) Do(f func() (map[string]any, error)) *MockStoreMapCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreMapCall) DoAndReturn(f func() (map[string]any, error)) *MockStoreMapCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Name mocks base method.
func (m *MockStore) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockStoreMockRecorder) Name() *MockStoreNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockStore)(nil).Name))
	return &MockStoreNameCall{Call: call}
}

// MockStoreNameCall wrap *gomock.Call
type MockStoreNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreNameCall) Return(arg0 string) *MockStoreNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreNameCall) Do(f func() string) *MockStoreNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreNameCall) DoAndReturn(f func() string) *MockStoreNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}