// Code generated by MockGen. DO NOT EDIT.
// Source: go.opentelemetry.io/otel/metric (interfaces: Meter,Int64UpDownCounter,Int64Counter)
//
// Generated by this command:
//
//	mockgen -typed -destination otel.go -package mock_otel go.opentelemetry.io/otel/metric Meter,Int64UpDownCounter,Int64Counter
//

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

import (
	context "context"
	reflect "reflect"

	metric "go.opentelemetry.io/otel/metric"
	"go.opentelemetry.io/otel/metric/embedded"
	gomock "go.uber.org/mock/gomock"
)

// MockMeter is a mock of Meter interface.
type MockMeter struct {
	embedded.Meter
	ctrl     *gomock.Controller
	recorder *MockMeterMockRecorder
	isgomock struct{}
}

// MockMeterMockRecorder is the mock recorder for MockMeter.
type MockMeterMockRecorder struct {
	mock *MockMeter
}

// NewMockMeter creates a new mock instance.
func NewMockMeter(ctrl *gomock.Controller) *MockMeter {
	mock := &MockMeter{ctrl: ctrl}
	mock.recorder = &MockMeterMockRecorder{mock}
	return mock
}

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

// Float64Counter mocks base method.
func (m *MockMeter) Float64Counter(name string, options ...metric.Float64CounterOption) (metric.Float64Counter, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float64Counter", varargs...)
	ret0, _ := ret[0].(metric.Float64Counter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Float64Counter indicates an expected call of Float64Counter.
func (mr *MockMeterMockRecorder) Float64Counter(name any, options ...any) *MockMeterFloat64CounterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64Counter", reflect.TypeOf((*MockMeter)(nil).Float64Counter), varargs...)
	return &MockMeterFloat64CounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterFloat64CounterCall) Return(arg0 metric.Float64Counter, arg1 error) *MockMeterFloat64CounterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterFloat64CounterCall) Do(f func(string, ...metric.Float64CounterOption) (metric.Float64Counter, error)) *MockMeterFloat64CounterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterFloat64CounterCall) DoAndReturn(f func(string, ...metric.Float64CounterOption) (metric.Float64Counter, error)) *MockMeterFloat64CounterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Float64Gauge mocks base method.
func (m *MockMeter) Float64Gauge(name string, options ...metric.Float64GaugeOption) (metric.Float64Gauge, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float64Gauge", varargs...)
	ret0, _ := ret[0].(metric.Float64Gauge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Float64Gauge indicates an expected call of Float64Gauge.
func (mr *MockMeterMockRecorder) Float64Gauge(name any, options ...any) *MockMeterFloat64GaugeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64Gauge", reflect.TypeOf((*MockMeter)(nil).Float64Gauge), varargs...)
	return &MockMeterFloat64GaugeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterFloat64GaugeCall) Return(arg0 metric.Float64Gauge, arg1 error) *MockMeterFloat64GaugeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterFloat64GaugeCall) Do(f func(string, ...metric.Float64GaugeOption) (metric.Float64Gauge, error)) *MockMeterFloat64GaugeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterFloat64GaugeCall) DoAndReturn(f func(string, ...metric.Float64GaugeOption) (metric.Float64Gauge, error)) *MockMeterFloat64GaugeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Float64Histogram mocks base method.
func (m *MockMeter) Float64Histogram(name string, options ...metric.Float64HistogramOption) (metric.Float64Histogram, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float64Histogram", varargs...)
	ret0, _ := ret[0].(metric.Float64Histogram)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Float64Histogram indicates an expected call of Float64Histogram.
func (mr *MockMeterMockRecorder) Float64Histogram(name any, options ...any) *MockMeterFloat64HistogramCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64Histogram", reflect.TypeOf((*MockMeter)(nil).Float64Histogram), varargs...)
	return &MockMeterFloat64HistogramCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterFloat64HistogramCall) Return(arg0 metric.Float64Histogram, arg1 error) *MockMeterFloat64HistogramCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterFloat64HistogramCall) Do(f func(string, ...metric.Float64HistogramOption) (metric.Float64Histogram, error)) *MockMeterFloat64HistogramCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterFloat64HistogramCall) DoAndReturn(f func(string, ...metric.Float64HistogramOption) (metric.Float64Histogram, error)) *MockMeterFloat64HistogramCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Float64ObservableCounter mocks base method.
func (m *MockMeter) Float64ObservableCounter(name string, options ...metric.Float64ObservableCounterOption) (metric.Float64ObservableCounter, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float64ObservableCounter", varargs...)
	ret0, _ := ret[0].(metric.Float64ObservableCounter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Float64ObservableCounter indicates an expected call of Float64ObservableCounter.
func (mr *MockMeterMockRecorder) Float64ObservableCounter(name any, options ...any) *MockMeterFloat64ObservableCounterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64ObservableCounter", reflect.TypeOf((*MockMeter)(nil).Float64ObservableCounter), varargs...)
	return &MockMeterFloat64ObservableCounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterFloat64ObservableCounterCall) Return(arg0 metric.Float64ObservableCounter, arg1 error) *MockMeterFloat64ObservableCounterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterFloat64ObservableCounterCall) Do(f func(string, ...metric.Float64ObservableCounterOption) (metric.Float64ObservableCounter, error)) *MockMeterFloat64ObservableCounterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterFloat64ObservableCounterCall) DoAndReturn(f func(string, ...metric.Float64ObservableCounterOption) (metric.Float64ObservableCounter, error)) *MockMeterFloat64ObservableCounterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Float64ObservableGauge mocks base method.
func (m *MockMeter) Float64ObservableGauge(name string, options ...metric.Float64ObservableGaugeOption) (metric.Float64ObservableGauge, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float64ObservableGauge", varargs...)
	ret0, _ := ret[0].(metric.Float64ObservableGauge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Float64ObservableGauge indicates an expected call of Float64ObservableGauge.
func (mr *MockMeterMockRecorder) Float64ObservableGauge(name any, options ...any) *MockMeterFloat64ObservableGaugeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64ObservableGauge", reflect.TypeOf((*MockMeter)(nil).Float64ObservableGauge), varargs...)
	return &MockMeterFloat64ObservableGaugeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterFloat64ObservableGaugeCall) Return(arg0 metric.Float64ObservableGauge, arg1 error) *MockMeterFloat64ObservableGaugeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterFloat64ObservableGaugeCall) Do(f func(string, ...metric.Float64ObservableGaugeOption) (metric.Float64ObservableGauge, error)) *MockMeterFloat64ObservableGaugeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterFloat64ObservableGaugeCall) DoAndReturn(f func(string, ...metric.Float64ObservableGaugeOption) (metric.Float64ObservableGauge, error)) *MockMeterFloat64ObservableGaugeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Float64ObservableUpDownCounter mocks base method.
func (m *MockMeter) Float64ObservableUpDownCounter(name string, options ...metric.Float64ObservableUpDownCounterOption) (metric.Float64ObservableUpDownCounter, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float64ObservableUpDownCounter", varargs...)
	ret0, _ := ret[0].(metric.Float64ObservableUpDownCounter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Float64ObservableUpDownCounter indicates an expected call of Float64ObservableUpDownCounter.
func (mr *MockMeterMockRecorder) Float64ObservableUpDownCounter(name any, options ...any) *MockMeterFloat64ObservableUpDownCounterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64ObservableUpDownCounter", reflect.TypeOf((*MockMeter)(nil).Float64ObservableUpDownCounter), varargs...)
	return &MockMeterFloat64ObservableUpDownCounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterFloat64ObservableUpDownCounterCall) Return(arg0 metric.Float64ObservableUpDownCounter, arg1 error) *MockMeterFloat64ObservableUpDownCounterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterFloat64ObservableUpDownCounterCall) Do(f func(string, ...metric.Float64ObservableUpDownCounterOption) (metric.Float64ObservableUpDownCounter, error)) *MockMeterFloat64ObservableUpDownCounterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterFloat64ObservableUpDownCounterCall) DoAndReturn(f func(string, ...metric.Float64ObservableUpDownCounterOption) (metric.Float64ObservableUpDownCounter, error)) *MockMeterFloat64ObservableUpDownCounterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Float64UpDownCounter mocks base method.
func (m *MockMeter) Float64UpDownCounter(name string, options ...metric.Float64UpDownCounterOption) (metric.Float64UpDownCounter, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Float64UpDownCounter", varargs...)
	ret0, _ := ret[0].(metric.Float64UpDownCounter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Float64UpDownCounter indicates an expected call of Float64UpDownCounter.
func (mr *MockMeterMockRecorder) Float64UpDownCounter(name any, options ...any) *MockMeterFloat64UpDownCounterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64UpDownCounter", reflect.TypeOf((*MockMeter)(nil).Float64UpDownCounter), varargs...)
	return &MockMeterFloat64UpDownCounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterFloat64UpDownCounterCall) Return(arg0 metric.Float64UpDownCounter, arg1 error) *MockMeterFloat64UpDownCounterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterFloat64UpDownCounterCall) Do(f func(string, ...metric.Float64UpDownCounterOption) (metric.Float64UpDownCounter, error)) *MockMeterFloat64UpDownCounterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterFloat64UpDownCounterCall) DoAndReturn(f func(string, ...metric.Float64UpDownCounterOption) (metric.Float64UpDownCounter, error)) *MockMeterFloat64UpDownCounterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Int64Counter mocks base method.
func (m *MockMeter) Int64Counter(name string, options ...metric.Int64CounterOption) (metric.Int64Counter, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int64Counter", varargs...)
	ret0, _ := ret[0].(metric.Int64Counter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Int64Counter indicates an expected call of Int64Counter.
func (mr *MockMeterMockRecorder) Int64Counter(name any, options ...any) *MockMeterInt64CounterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64Counter", reflect.TypeOf((*MockMeter)(nil).Int64Counter), varargs...)
	return &MockMeterInt64CounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterInt64CounterCall) Return(arg0 metric.Int64Counter, arg1 error) *MockMeterInt64CounterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterInt64CounterCall) Do(f func(string, ...metric.Int64CounterOption) (metric.Int64Counter, error)) *MockMeterInt64CounterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterInt64CounterCall) DoAndReturn(f func(string, ...metric.Int64CounterOption) (metric.Int64Counter, error)) *MockMeterInt64CounterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Int64Gauge mocks base method.
func (m *MockMeter) Int64Gauge(name string, options ...metric.Int64GaugeOption) (metric.Int64Gauge, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int64Gauge", varargs...)
	ret0, _ := ret[0].(metric.Int64Gauge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Int64Gauge indicates an expected call of Int64Gauge.
func (mr *MockMeterMockRecorder) Int64Gauge(name any, options ...any) *MockMeterInt64GaugeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64Gauge", reflect.TypeOf((*MockMeter)(nil).Int64Gauge), varargs...)
	return &MockMeterInt64GaugeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterInt64GaugeCall) Return(arg0 metric.Int64Gauge, arg1 error) *MockMeterInt64GaugeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterInt64GaugeCall) Do(f func(string, ...metric.Int64GaugeOption) (metric.Int64Gauge, error)) *MockMeterInt64GaugeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterInt64GaugeCall) DoAndReturn(f func(string, ...metric.Int64GaugeOption) (metric.Int64Gauge, error)) *MockMeterInt64GaugeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Int64Histogram mocks base method.
func (m *MockMeter) Int64Histogram(name string, options ...metric.Int64HistogramOption) (metric.Int64Histogram, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int64Histogram", varargs...)
	ret0, _ := ret[0].(metric.Int64Histogram)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Int64Histogram indicates an expected call of Int64Histogram.
func (mr *MockMeterMockRecorder) Int64Histogram(name any, options ...any) *MockMeterInt64HistogramCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64Histogram", reflect.TypeOf((*MockMeter)(nil).Int64Histogram), varargs...)
	return &MockMeterInt64HistogramCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterInt64HistogramCall) Return(arg0 metric.Int64Histogram, arg1 error) *MockMeterInt64HistogramCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterInt64HistogramCall) Do(f func(string, ...metric.Int64HistogramOption) (metric.Int64Histogram, error)) *MockMeterInt64HistogramCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterInt64HistogramCall) DoAndReturn(f func(string, ...metric.Int64HistogramOption) (metric.Int64Histogram, error)) *MockMeterInt64HistogramCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Int64ObservableCounter mocks base method.
func (m *MockMeter) Int64ObservableCounter(name string, options ...metric.Int64ObservableCounterOption) (metric.Int64ObservableCounter, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int64ObservableCounter", varargs...)
	ret0, _ := ret[0].(metric.Int64ObservableCounter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Int64ObservableCounter indicates an expected call of Int64ObservableCounter.
func (mr *MockMeterMockRecorder) Int64ObservableCounter(name any, options ...any) *MockMeterInt64ObservableCounterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64ObservableCounter", reflect.TypeOf((*MockMeter)(nil).Int64ObservableCounter), varargs...)
	return &MockMeterInt64ObservableCounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterInt64ObservableCounterCall) Return(arg0 metric.Int64ObservableCounter, arg1 error) *MockMeterInt64ObservableCounterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterInt64ObservableCounterCall) Do(f func(string, ...metric.Int64ObservableCounterOption) (metric.Int64ObservableCounter, error)) *MockMeterInt64ObservableCounterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterInt64ObservableCounterCall) DoAndReturn(f func(string, ...metric.Int64ObservableCounterOption) (metric.Int64ObservableCounter, error)) *MockMeterInt64ObservableCounterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Int64ObservableGauge mocks base method.
func (m *MockMeter) Int64ObservableGauge(name string, options ...metric.Int64ObservableGaugeOption) (metric.Int64ObservableGauge, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int64ObservableGauge", varargs...)
	ret0, _ := ret[0].(metric.Int64ObservableGauge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Int64ObservableGauge indicates an expected call of Int64ObservableGauge.
func (mr *MockMeterMockRecorder) Int64ObservableGauge(name any, options ...any) *MockMeterInt64ObservableGaugeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64ObservableGauge", reflect.TypeOf((*MockMeter)(nil).Int64ObservableGauge), varargs...)
	return &MockMeterInt64ObservableGaugeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterInt64ObservableGaugeCall) Return(arg0 metric.Int64ObservableGauge, arg1 error) *MockMeterInt64ObservableGaugeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterInt64ObservableGaugeCall) Do(f func(string, ...metric.Int64ObservableGaugeOption) (metric.Int64ObservableGauge, error)) *MockMeterInt64ObservableGaugeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterInt64ObservableGaugeCall) DoAndReturn(f func(string, ...metric.Int64ObservableGaugeOption) (metric.Int64ObservableGauge, error)) *MockMeterInt64ObservableGaugeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Int64ObservableUpDownCounter mocks base method.
func (m *MockMeter) Int64ObservableUpDownCounter(name string, options ...metric.Int64ObservableUpDownCounterOption) (metric.Int64ObservableUpDownCounter, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int64ObservableUpDownCounter", varargs...)
	ret0, _ := ret[0].(metric.Int64ObservableUpDownCounter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Int64ObservableUpDownCounter indicates an expected call of Int64ObservableUpDownCounter.
func (mr *MockMeterMockRecorder) Int64ObservableUpDownCounter(name any, options ...any) *MockMeterInt64ObservableUpDownCounterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64ObservableUpDownCounter", reflect.TypeOf((*MockMeter)(nil).Int64ObservableUpDownCounter), varargs...)
	return &MockMeterInt64ObservableUpDownCounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterInt64ObservableUpDownCounterCall) Return(arg0 metric.Int64ObservableUpDownCounter, arg1 error) *MockMeterInt64ObservableUpDownCounterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterInt64ObservableUpDownCounterCall) Do(f func(string, ...metric.Int64ObservableUpDownCounterOption) (metric.Int64ObservableUpDownCounter, error)) *MockMeterInt64ObservableUpDownCounterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterInt64ObservableUpDownCounterCall) DoAndReturn(f func(string, ...metric.Int64ObservableUpDownCounterOption) (metric.Int64ObservableUpDownCounter, error)) *MockMeterInt64ObservableUpDownCounterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Int64UpDownCounter mocks base method.
func (m *MockMeter) Int64UpDownCounter(name string, options ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Int64UpDownCounter", varargs...)
	ret0, _ := ret[0].(metric.Int64UpDownCounter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Int64UpDownCounter indicates an expected call of Int64UpDownCounter.
func (mr *MockMeterMockRecorder) Int64UpDownCounter(name any, options ...any) *MockMeterInt64UpDownCounterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64UpDownCounter", reflect.TypeOf((*MockMeter)(nil).Int64UpDownCounter), varargs...)
	return &MockMeterInt64UpDownCounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterInt64UpDownCounterCall) Return(arg0 metric.Int64UpDownCounter, arg1 error) *MockMeterInt64UpDownCounterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterInt64UpDownCounterCall) Do(f func(string, ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error)) *MockMeterInt64UpDownCounterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterInt64UpDownCounterCall) DoAndReturn(f func(string, ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error)) *MockMeterInt64UpDownCounterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RegisterCallback mocks base method.
func (m *MockMeter) RegisterCallback(f metric.Callback, instruments ...metric.Observable) (metric.Registration, error) {
	m.ctrl.T.Helper()
	varargs := []any{f}
	for _, a := range instruments {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterCallback", varargs...)
	ret0, _ := ret[0].(metric.Registration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterCallback indicates an expected call of RegisterCallback.
func (mr *MockMeterMockRecorder) RegisterCallback(f any, instruments ...any) *MockMeterRegisterCallbackCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{f}, instruments...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCallback", reflect.TypeOf((*MockMeter)(nil).RegisterCallback), varargs...)
	return &MockMeterRegisterCallbackCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMeterRegisterCallbackCall) Return(arg0 metric.Registration, arg1 error) *MockMeterRegisterCallbackCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockMeterRegisterCallbackCall) Do(f func(metric.Callback, ...metric.Observable) (metric.Registration, error)) *MockMeterRegisterCallbackCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMeterRegisterCallbackCall) DoAndReturn(f func(metric.Callback, ...metric.Observable) (metric.Registration, error)) *MockMeterRegisterCallbackCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// meter indicates an expected call of meter.
func (mr *MockMeterMockRecorder) meter() *MockMetermeterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "meter", reflect.TypeOf((*MockMeter)(nil).meter))
	return &MockMetermeterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockMetermeterCall) Return() *MockMetermeterCall {
	c.Call = c.Call.Return()
	return c
}

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

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

// MockInt64UpDownCounter is a mock of Int64UpDownCounter interface.
type MockInt64UpDownCounter struct {
	embedded.Int64UpDownCounter
	ctrl     *gomock.Controller
	recorder *MockInt64UpDownCounterMockRecorder
	isgomock struct{}
}

// MockInt64UpDownCounterMockRecorder is the mock recorder for MockInt64UpDownCounter.
type MockInt64UpDownCounterMockRecorder struct {
	mock *MockInt64UpDownCounter
}

// NewMockInt64UpDownCounter creates a new mock instance.
func NewMockInt64UpDownCounter(ctrl *gomock.Controller) *MockInt64UpDownCounter {
	mock := &MockInt64UpDownCounter{ctrl: ctrl}
	mock.recorder = &MockInt64UpDownCounterMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockInt64UpDownCounter) Add(ctx context.Context, incr int64, options ...metric.AddOption) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, incr}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Add", varargs...)
}

// Add indicates an expected call of Add.
func (mr *MockInt64UpDownCounterMockRecorder) Add(ctx, incr any, options ...any) *MockInt64UpDownCounterAddCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, incr}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockInt64UpDownCounter)(nil).Add), varargs...)
	return &MockInt64UpDownCounterAddCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockInt64UpDownCounterAddCall) Return() *MockInt64UpDownCounterAddCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInt64UpDownCounterAddCall) Do(f func(context.Context, int64, ...metric.AddOption)) *MockInt64UpDownCounterAddCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInt64UpDownCounterAddCall) DoAndReturn(f func(context.Context, int64, ...metric.AddOption)) *MockInt64UpDownCounterAddCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// int64UpDownCounter indicates an expected call of int64UpDownCounter.
func (mr *MockInt64UpDownCounterMockRecorder) int64UpDownCounter() *MockInt64UpDownCounterint64UpDownCounterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "int64UpDownCounter", reflect.TypeOf((*MockInt64UpDownCounter)(nil).int64UpDownCounter))
	return &MockInt64UpDownCounterint64UpDownCounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockInt64UpDownCounterint64UpDownCounterCall) Return() *MockInt64UpDownCounterint64UpDownCounterCall {
	c.Call = c.Call.Return()
	return c
}

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

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

// MockInt64Counter is a mock of Int64Counter interface.
type MockInt64Counter struct {
	embedded.Int64Counter
	ctrl     *gomock.Controller
	recorder *MockInt64CounterMockRecorder
	isgomock struct{}
}

// MockInt64CounterMockRecorder is the mock recorder for MockInt64Counter.
type MockInt64CounterMockRecorder struct {
	mock *MockInt64Counter
}

// NewMockInt64Counter creates a new mock instance.
func NewMockInt64Counter(ctrl *gomock.Controller) *MockInt64Counter {
	mock := &MockInt64Counter{ctrl: ctrl}
	mock.recorder = &MockInt64CounterMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockInt64Counter) Add(ctx context.Context, incr int64, options ...metric.AddOption) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, incr}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Add", varargs...)
}

// Add indicates an expected call of Add.
func (mr *MockInt64CounterMockRecorder) Add(ctx, incr any, options ...any) *MockInt64CounterAddCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, incr}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockInt64Counter)(nil).Add), varargs...)
	return &MockInt64CounterAddCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockInt64CounterAddCall) Return() *MockInt64CounterAddCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInt64CounterAddCall) Do(f func(context.Context, int64, ...metric.AddOption)) *MockInt64CounterAddCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInt64CounterAddCall) DoAndReturn(f func(context.Context, int64, ...metric.AddOption)) *MockInt64CounterAddCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// int64Counter indicates an expected call of int64Counter.
func (mr *MockInt64CounterMockRecorder) int64Counter() *MockInt64Counterint64CounterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "int64Counter", reflect.TypeOf((*MockInt64Counter)(nil).int64Counter))
	return &MockInt64Counterint64CounterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockInt64Counterint64CounterCall) Return() *MockInt64Counterint64CounterCall {
	c.Call = c.Call.Return()
	return c
}

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

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