func (mr *MockUserScopeMockRecorder) IncCounter(counter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncCounter", reflect.TypeOf((*MockUserScope)(nil).IncCounter), counter)
}
IncCounter indicates an expected call of IncCounter.
package metrics
import (
	reflect "reflect"
	time "time"
	gomock "github.com/golang/mock/gomock"
	log "go.temporal.io/server/common/log"
)
type MockStopwatch struct {
	ctrl     *gomock.Controller
	recorder *MockStopwatchMockRecorder
}
type MockStopwatchMockRecorder struct {
	mock *MockStopwatch
}
func NewMockStopwatch(ctrl *gomock.Controller) *MockStopwatch {
	mock := &MockStopwatch{ctrl: ctrl}
	mock.recorder = &MockStopwatchMockRecorder{mock}
	return mock
}
func (m *MockStopwatch) EXPECT() *MockStopwatchMockRecorder {
	return m.recorder
}
func (m *MockStopwatch) Stop() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Stop")
}
func (mr *MockStopwatchMockRecorder) Stop() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockStopwatch)(nil).Stop))
}
func (m *MockStopwatch) Subtract(d time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Subtract", d)
}
func (mr *MockStopwatchMockRecorder) Subtract(d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subtract", reflect.TypeOf((*MockStopwatch)(nil).Subtract), d)
}
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}
type MockClientMockRecorder struct {
	mock *MockClient
}
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}
func (m *MockClient) EXPECT() *MockClientMockRecorder {
	return m.recorder
}
func (m *MockClient) AddCounter(scope, counter int, delta int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddCounter", scope, counter, delta)
}
func (mr *MockClientMockRecorder) AddCounter(scope, counter, delta interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCounter", reflect.TypeOf((*MockClient)(nil).AddCounter), scope, counter, delta)
}
func (m *MockClient) IncCounter(scope, counter int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncCounter", scope, counter)
}
func (mr *MockClientMockRecorder) IncCounter(scope, counter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncCounter", reflect.TypeOf((*MockClient)(nil).IncCounter), scope, counter)
}
func (m *MockClient) RecordDistribution(scope, timer, d int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordDistribution", scope, timer, d)
}
func (mr *MockClientMockRecorder) RecordDistribution(scope, timer, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordDistribution", reflect.TypeOf((*MockClient)(nil).RecordDistribution), scope, timer, d)
}
func (m *MockClient) RecordTimer(scope, timer int, d time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordTimer", scope, timer, d)
}
func (mr *MockClientMockRecorder) RecordTimer(scope, timer, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordTimer", reflect.TypeOf((*MockClient)(nil).RecordTimer), scope, timer, d)
}
func (m *MockClient) Scope(scope int, tags ...Tag) Scope {
	m.ctrl.T.Helper()
	varargs := []interface{}{scope}
	for _, a := range tags {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Scope", varargs...)
	ret0, _ := ret[0].(Scope)
	return ret0
}
func (mr *MockClientMockRecorder) Scope(scope interface{}, tags ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{scope}, tags...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scope", reflect.TypeOf((*MockClient)(nil).Scope), varargs...)
}
func (m *MockClient) StartTimer(scope, timer int) Stopwatch {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartTimer", scope, timer)
	ret0, _ := ret[0].(Stopwatch)
	return ret0
}
func (mr *MockClientMockRecorder) StartTimer(scope, timer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTimer", reflect.TypeOf((*MockClient)(nil).StartTimer), scope, timer)
}
func (m *MockClient) UpdateGauge(scope, gauge int, value float64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateGauge", scope, gauge, value)
}
func (mr *MockClientMockRecorder) UpdateGauge(scope, gauge, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGauge", reflect.TypeOf((*MockClient)(nil).UpdateGauge), scope, gauge, value)
}
func (m *MockClient) UserScope() UserScope {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserScope")
	ret0, _ := ret[0].(UserScope)
	return ret0
}
func (mr *MockClientMockRecorder) UserScope() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserScope", reflect.TypeOf((*MockClient)(nil).UserScope))
}
type MockScope struct {
	ctrl     *gomock.Controller
	recorder *MockScopeMockRecorder
}
type MockScopeMockRecorder struct {
	mock *MockScope
}
func NewMockScope(ctrl *gomock.Controller) *MockScope {
	mock := &MockScope{ctrl: ctrl}
	mock.recorder = &MockScopeMockRecorder{mock}
	return mock
}
func (m *MockScope) EXPECT() *MockScopeMockRecorder {
	return m.recorder
}
func (m *MockScope) AddCounter(counter int, delta int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddCounter", counter, delta)
}
func (mr *MockScopeMockRecorder) AddCounter(counter, delta interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCounter", reflect.TypeOf((*MockScope)(nil).AddCounter), counter, delta)
}
func (m *MockScope) IncCounter(counter int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncCounter", counter)
}
func (mr *MockScopeMockRecorder) IncCounter(counter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncCounter", reflect.TypeOf((*MockScope)(nil).IncCounter), counter)
}
func (m *MockScope) RecordDistribution(id, d int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordDistribution", id, d)
}
func (mr *MockScopeMockRecorder) RecordDistribution(id, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordDistribution", reflect.TypeOf((*MockScope)(nil).RecordDistribution), id, d)
}
func (m *MockScope) RecordTimer(timer int, d time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordTimer", timer, d)
}
func (mr *MockScopeMockRecorder) RecordTimer(timer, d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordTimer", reflect.TypeOf((*MockScope)(nil).RecordTimer), timer, d)
}
func (m *MockScope) StartTimer(timer int) Stopwatch {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartTimer", timer)
	ret0, _ := ret[0].(Stopwatch)
	return ret0
}
func (mr *MockScopeMockRecorder) StartTimer(timer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTimer", reflect.TypeOf((*MockScope)(nil).StartTimer), timer)
}
func (m *MockScope) Tagged(tags ...Tag) Scope {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range tags {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Tagged", varargs...)
	ret0, _ := ret[0].(Scope)
	return ret0
}
func (mr *MockScopeMockRecorder) Tagged(tags ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tagged", reflect.TypeOf((*MockScope)(nil).Tagged), tags...)
}
func (m *MockScope) UpdateGauge(gauge int, value float64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateGauge", gauge, value)
}
func (mr *MockScopeMockRecorder) UpdateGauge(gauge, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGauge", reflect.TypeOf((*MockScope)(nil).UpdateGauge), gauge, value)
}
type MockUserScope struct {
	ctrl     *gomock.Controller
	recorder *MockUserScopeMockRecorder
}
type MockUserScopeMockRecorder struct {
	mock *MockUserScope
}
func NewMockUserScope(ctrl *gomock.Controller) *MockUserScope {
	mock := &MockUserScope{ctrl: ctrl}
	mock.recorder = &MockUserScopeMockRecorder{mock}
	return mock
}
func (m *MockUserScope) EXPECT() *MockUserScopeMockRecorder {
	return m.recorder
}
func (m *MockUserScope) AddCounter(counter string, delta int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddCounter", counter, delta)
}
func (mr *MockUserScopeMockRecorder) AddCounter(counter, delta interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCounter", reflect.TypeOf((*MockUserScope)(nil).AddCounter), counter, delta)
}
func (m *MockUserScope) IncCounter(counter string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncCounter", counter)
}