// Code generated by MockGen. DO NOT EDIT.
// Source: client.go
//
// Generated by this command:
//
//	mockgen -source=client.go -package=mock -destination=./mock/client.go
//

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

import (
	context "context"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"

	experiment "github.com/bucketeer-io/bucketeer/v2/proto/experiment"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

// ArchiveExperiment mocks base method.
func (m *MockClient) ArchiveExperiment(ctx context.Context, in *experiment.ArchiveExperimentRequest, opts ...grpc.CallOption) (*experiment.ArchiveExperimentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ArchiveExperiment", varargs...)
	ret0, _ := ret[0].(*experiment.ArchiveExperimentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ArchiveExperiment indicates an expected call of ArchiveExperiment.
func (mr *MockClientMockRecorder) ArchiveExperiment(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArchiveExperiment", reflect.TypeOf((*MockClient)(nil).ArchiveExperiment), varargs...)
}

// ArchiveGoal mocks base method.
func (m *MockClient) ArchiveGoal(ctx context.Context, in *experiment.ArchiveGoalRequest, opts ...grpc.CallOption) (*experiment.ArchiveGoalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ArchiveGoal", varargs...)
	ret0, _ := ret[0].(*experiment.ArchiveGoalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ArchiveGoal indicates an expected call of ArchiveGoal.
func (mr *MockClientMockRecorder) ArchiveGoal(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArchiveGoal", reflect.TypeOf((*MockClient)(nil).ArchiveGoal), varargs...)
}

// Close mocks base method.
func (m *MockClient) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockClientMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close))
}

// CreateExperiment mocks base method.
func (m *MockClient) CreateExperiment(ctx context.Context, in *experiment.CreateExperimentRequest, opts ...grpc.CallOption) (*experiment.CreateExperimentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateExperiment", varargs...)
	ret0, _ := ret[0].(*experiment.CreateExperimentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateExperiment indicates an expected call of CreateExperiment.
func (mr *MockClientMockRecorder) CreateExperiment(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExperiment", reflect.TypeOf((*MockClient)(nil).CreateExperiment), varargs...)
}

// CreateGoal mocks base method.
func (m *MockClient) CreateGoal(ctx context.Context, in *experiment.CreateGoalRequest, opts ...grpc.CallOption) (*experiment.CreateGoalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGoal", varargs...)
	ret0, _ := ret[0].(*experiment.CreateGoalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGoal indicates an expected call of CreateGoal.
func (mr *MockClientMockRecorder) CreateGoal(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGoal", reflect.TypeOf((*MockClient)(nil).CreateGoal), varargs...)
}

// DeleteExperiment mocks base method.
func (m *MockClient) DeleteExperiment(ctx context.Context, in *experiment.DeleteExperimentRequest, opts ...grpc.CallOption) (*experiment.DeleteExperimentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteExperiment", varargs...)
	ret0, _ := ret[0].(*experiment.DeleteExperimentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteExperiment indicates an expected call of DeleteExperiment.
func (mr *MockClientMockRecorder) DeleteExperiment(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExperiment", reflect.TypeOf((*MockClient)(nil).DeleteExperiment), varargs...)
}

// DeleteGoal mocks base method.
func (m *MockClient) DeleteGoal(ctx context.Context, in *experiment.DeleteGoalRequest, opts ...grpc.CallOption) (*experiment.DeleteGoalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteGoal", varargs...)
	ret0, _ := ret[0].(*experiment.DeleteGoalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteGoal indicates an expected call of DeleteGoal.
func (mr *MockClientMockRecorder) DeleteGoal(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGoal", reflect.TypeOf((*MockClient)(nil).DeleteGoal), varargs...)
}

// FinishExperiment mocks base method.
func (m *MockClient) FinishExperiment(ctx context.Context, in *experiment.FinishExperimentRequest, opts ...grpc.CallOption) (*experiment.FinishExperimentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FinishExperiment", varargs...)
	ret0, _ := ret[0].(*experiment.FinishExperimentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FinishExperiment indicates an expected call of FinishExperiment.
func (mr *MockClientMockRecorder) FinishExperiment(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishExperiment", reflect.TypeOf((*MockClient)(nil).FinishExperiment), varargs...)
}

// GetExperiment mocks base method.
func (m *MockClient) GetExperiment(ctx context.Context, in *experiment.GetExperimentRequest, opts ...grpc.CallOption) (*experiment.GetExperimentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetExperiment", varargs...)
	ret0, _ := ret[0].(*experiment.GetExperimentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExperiment indicates an expected call of GetExperiment.
func (mr *MockClientMockRecorder) GetExperiment(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExperiment", reflect.TypeOf((*MockClient)(nil).GetExperiment), varargs...)
}

// GetGoal mocks base method.
func (m *MockClient) GetGoal(ctx context.Context, in *experiment.GetGoalRequest, opts ...grpc.CallOption) (*experiment.GetGoalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGoal", varargs...)
	ret0, _ := ret[0].(*experiment.GetGoalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGoal indicates an expected call of GetGoal.
func (mr *MockClientMockRecorder) GetGoal(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGoal", reflect.TypeOf((*MockClient)(nil).GetGoal), varargs...)
}

// ListExperiments mocks base method.
func (m *MockClient) ListExperiments(ctx context.Context, in *experiment.ListExperimentsRequest, opts ...grpc.CallOption) (*experiment.ListExperimentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListExperiments", varargs...)
	ret0, _ := ret[0].(*experiment.ListExperimentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListExperiments indicates an expected call of ListExperiments.
func (mr *MockClientMockRecorder) ListExperiments(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExperiments", reflect.TypeOf((*MockClient)(nil).ListExperiments), varargs...)
}

// ListGoals mocks base method.
func (m *MockClient) ListGoals(ctx context.Context, in *experiment.ListGoalsRequest, opts ...grpc.CallOption) (*experiment.ListGoalsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGoals", varargs...)
	ret0, _ := ret[0].(*experiment.ListGoalsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGoals indicates an expected call of ListGoals.
func (mr *MockClientMockRecorder) ListGoals(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGoals", reflect.TypeOf((*MockClient)(nil).ListGoals), varargs...)
}

// StartExperiment mocks base method.
func (m *MockClient) StartExperiment(ctx context.Context, in *experiment.StartExperimentRequest, opts ...grpc.CallOption) (*experiment.StartExperimentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartExperiment", varargs...)
	ret0, _ := ret[0].(*experiment.StartExperimentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartExperiment indicates an expected call of StartExperiment.
func (mr *MockClientMockRecorder) StartExperiment(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartExperiment", reflect.TypeOf((*MockClient)(nil).StartExperiment), varargs...)
}

// StopExperiment mocks base method.
func (m *MockClient) StopExperiment(ctx context.Context, in *experiment.StopExperimentRequest, opts ...grpc.CallOption) (*experiment.StopExperimentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopExperiment", varargs...)
	ret0, _ := ret[0].(*experiment.StopExperimentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopExperiment indicates an expected call of StopExperiment.
func (mr *MockClientMockRecorder) StopExperiment(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopExperiment", reflect.TypeOf((*MockClient)(nil).StopExperiment), varargs...)
}

// UpdateExperiment mocks base method.
func (m *MockClient) UpdateExperiment(ctx context.Context, in *experiment.UpdateExperimentRequest, opts ...grpc.CallOption) (*experiment.UpdateExperimentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateExperiment", varargs...)
	ret0, _ := ret[0].(*experiment.UpdateExperimentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateExperiment indicates an expected call of UpdateExperiment.
func (mr *MockClientMockRecorder) UpdateExperiment(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExperiment", reflect.TypeOf((*MockClient)(nil).UpdateExperiment), varargs...)
}

// UpdateGoal mocks base method.
func (m *MockClient) UpdateGoal(ctx context.Context, in *experiment.UpdateGoalRequest, opts ...grpc.CallOption) (*experiment.UpdateGoalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGoal", varargs...)
	ret0, _ := ret[0].(*experiment.UpdateGoalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGoal indicates an expected call of UpdateGoal.
func (mr *MockClientMockRecorder) UpdateGoal(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGoal", reflect.TypeOf((*MockClient)(nil).UpdateGoal), varargs...)
}
