zap_encoder.go

// Code generated by github.com/skipor/gmg - type-safe, fast and handy alternative GoMock generator. DO NOT EDIT.
// Source: github.com/skipor/gmg/examples/2_target_interface_select.ZapEncoder

package example_mocks

import (
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	buffer "go.uber.org/zap/buffer"
	zapcore "go.uber.org/zap/zapcore"
)

// NewMockZapEncoder creates a new GoMock for github.com/skipor/gmg/examples/2_target_interface_select.ZapEncoder.
func NewMockZapEncoder(ctrl *gomock.Controller) *MockZapEncoder {
	return &MockZapEncoder{ctrl: ctrl}
}

// MockZapEncoder is a GoMock of github.com/skipor/gmg/examples/2_target_interface_select.ZapEncoder.
type MockZapEncoder struct{ ctrl *gomock.Controller }

// EXPECT returns GoMock recorder.
func (m_ *MockZapEncoder) EXPECT() *MockZapEncoderMockRecorder {
	return (*MockZapEncoderMockRecorder)(m_)
}

// AddArray implements mocked interface.
func (m_ *MockZapEncoder) AddArray(key string, marshaler zapcore.ArrayMarshaler) error {
	m_.ctrl.T.Helper()
	res_ := m_.ctrl.Call(m_, "AddArray", key, marshaler)
	res0, _ := res_[0].(error)
	return res0
}

// AddBinary implements mocked interface.
func (m_ *MockZapEncoder) AddBinary(key string, value []byte) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddBinary", key, value)
	return
}

// AddBool implements mocked interface.
func (m_ *MockZapEncoder) AddBool(key string, value bool) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddBool", key, value)
	return
}

// AddByteString implements mocked interface.
func (m_ *MockZapEncoder) AddByteString(key string, value []byte) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddByteString", key, value)
	return
}

// AddComplex128 implements mocked interface.
func (m_ *MockZapEncoder) AddComplex128(key string, value complex128) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddComplex128", key, value)
	return
}

// AddComplex64 implements mocked interface.
func (m_ *MockZapEncoder) AddComplex64(key string, value complex64) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddComplex64", key, value)
	return
}

// AddDuration implements mocked interface.
func (m_ *MockZapEncoder) AddDuration(key string, value time.Duration) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddDuration", key, value)
	return
}

// AddFloat32 implements mocked interface.
func (m_ *MockZapEncoder) AddFloat32(key string, value float32) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddFloat32", key, value)
	return
}

// AddFloat64 implements mocked interface.
func (m_ *MockZapEncoder) AddFloat64(key string, value float64) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddFloat64", key, value)
	return
}

// AddInt implements mocked interface.
func (m_ *MockZapEncoder) AddInt(key string, value int) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddInt", key, value)
	return
}

// AddInt16 implements mocked interface.
func (m_ *MockZapEncoder) AddInt16(key string, value int16) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddInt16", key, value)
	return
}

// AddInt32 implements mocked interface.
func (m_ *MockZapEncoder) AddInt32(key string, value int32) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddInt32", key, value)
	return
}

// AddInt64 implements mocked interface.
func (m_ *MockZapEncoder) AddInt64(key string, value int64) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddInt64", key, value)
	return
}

// AddInt8 implements mocked interface.
func (m_ *MockZapEncoder) AddInt8(key string, value int8) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddInt8", key, value)
	return
}

// AddObject implements mocked interface.
func (m_ *MockZapEncoder) AddObject(key string, marshaler zapcore.ObjectMarshaler) error {
	m_.ctrl.T.Helper()
	res_ := m_.ctrl.Call(m_, "AddObject", key, marshaler)
	res0, _ := res_[0].(error)
	return res0
}

// AddReflected implements mocked interface.
func (m_ *MockZapEncoder) AddReflected(key string, value interface{}) error {
	m_.ctrl.T.Helper()
	res_ := m_.ctrl.Call(m_, "AddReflected", key, value)
	res0, _ := res_[0].(error)
	return res0
}

// AddString implements mocked interface.
func (m_ *MockZapEncoder) AddString(key string, value string) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddString", key, value)
	return
}

// AddTime implements mocked interface.
func (m_ *MockZapEncoder) AddTime(key string, value time.Time) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddTime", key, value)
	return
}

// AddUint implements mocked interface.
func (m_ *MockZapEncoder) AddUint(key string, value uint) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddUint", key, value)
	return
}

// AddUint16 implements mocked interface.
func (m_ *MockZapEncoder) AddUint16(key string, value uint16) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddUint16", key, value)
	return
}

// AddUint32 implements mocked interface.
func (m_ *MockZapEncoder) AddUint32(key string, value uint32) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddUint32", key, value)
	return
}

// AddUint64 implements mocked interface.
func (m_ *MockZapEncoder) AddUint64(key string, value uint64) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddUint64", key, value)
	return
}

// AddUint8 implements mocked interface.
func (m_ *MockZapEncoder) AddUint8(key string, value uint8) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddUint8", key, value)
	return
}

// AddUintptr implements mocked interface.
func (m_ *MockZapEncoder) AddUintptr(key string, value uintptr) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "AddUintptr", key, value)
	return
}

// Clone implements mocked interface.
func (m_ *MockZapEncoder) Clone() zapcore.Encoder {
	m_.ctrl.T.Helper()
	res_ := m_.ctrl.Call(m_, "Clone")
	res0, _ := res_[0].(zapcore.Encoder)
	return res0
}

// EncodeEntry implements mocked interface.
func (m_ *MockZapEncoder) EncodeEntry(arg zapcore.Entry, arg2 []zapcore.Field) (*buffer.Buffer, error) {
	m_.ctrl.T.Helper()
	res_ := m_.ctrl.Call(m_, "EncodeEntry", arg, arg2)
	res0, _ := res_[0].(*buffer.Buffer)
	res1, _ := res_[1].(error)
	return res0, res1
}

// OpenNamespace implements mocked interface.
func (m_ *MockZapEncoder) OpenNamespace(key string) {
	m_.ctrl.T.Helper()
	m_.ctrl.Call(m_, "OpenNamespace", key)
	return
}

// MockZapEncoderMockRecorder is the mock recorder for MockZapEncoder.
type MockZapEncoderMockRecorder MockZapEncoder

//   AddArray(key string, marshaler zapcore.ArrayMarshaler) error
func (r_ *MockZapEncoderMockRecorder) AddArray(key interface{}, marshaler interface{}) MockZapEncoderAddArrayCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddArray", reflect.TypeOf((*MockZapEncoder)(nil).AddArray), key, marshaler)
	return MockZapEncoderAddArrayCall{call}
}

// MockZapEncoderAddArrayCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddArrayCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddArrayCall) DoAndReturn(f func(key string, marshaler zapcore.ArrayMarshaler) error) MockZapEncoderAddArrayCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddArrayCall) Do(f func(key string, marshaler zapcore.ArrayMarshaler)) MockZapEncoderAddArrayCall {
	c_.Call.Do(f)
	return c_
}

// Return is type safe wrapper of *gomock.Call Return.
func (c_ MockZapEncoderAddArrayCall) Return(res0 error) MockZapEncoderAddArrayCall {
	c_.Call.Return(res0)
	return c_
}

//   AddBinary(key string, value []byte)
func (r_ *MockZapEncoderMockRecorder) AddBinary(key interface{}, value interface{}) MockZapEncoderAddBinaryCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddBinary", reflect.TypeOf((*MockZapEncoder)(nil).AddBinary), key, value)
	return MockZapEncoderAddBinaryCall{call}
}

// MockZapEncoderAddBinaryCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddBinaryCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddBinaryCall) DoAndReturn(f func(key string, value []byte)) MockZapEncoderAddBinaryCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddBinaryCall) Do(f func(key string, value []byte)) MockZapEncoderAddBinaryCall {
	c_.Call.Do(f)
	return c_
}

//   AddBool(key string, value bool)
func (r_ *MockZapEncoderMockRecorder) AddBool(key interface{}, value interface{}) MockZapEncoderAddBoolCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddBool", reflect.TypeOf((*MockZapEncoder)(nil).AddBool), key, value)
	return MockZapEncoderAddBoolCall{call}
}

// MockZapEncoderAddBoolCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddBoolCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddBoolCall) DoAndReturn(f func(key string, value bool)) MockZapEncoderAddBoolCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddBoolCall) Do(f func(key string, value bool)) MockZapEncoderAddBoolCall {
	c_.Call.Do(f)
	return c_
}

//   AddByteString(key string, value []byte)
func (r_ *MockZapEncoderMockRecorder) AddByteString(key interface{}, value interface{}) MockZapEncoderAddByteStringCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddByteString", reflect.TypeOf((*MockZapEncoder)(nil).AddByteString), key, value)
	return MockZapEncoderAddByteStringCall{call}
}

// MockZapEncoderAddByteStringCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddByteStringCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddByteStringCall) DoAndReturn(f func(key string, value []byte)) MockZapEncoderAddByteStringCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddByteStringCall) Do(f func(key string, value []byte)) MockZapEncoderAddByteStringCall {
	c_.Call.Do(f)
	return c_
}

//   AddComplex128(key string, value complex128)
func (r_ *MockZapEncoderMockRecorder) AddComplex128(key interface{}, value interface{}) MockZapEncoderAddComplex128Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddComplex128", reflect.TypeOf((*MockZapEncoder)(nil).AddComplex128), key, value)
	return MockZapEncoderAddComplex128Call{call}
}

// MockZapEncoderAddComplex128Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddComplex128Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddComplex128Call) DoAndReturn(f func(key string, value complex128)) MockZapEncoderAddComplex128Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddComplex128Call) Do(f func(key string, value complex128)) MockZapEncoderAddComplex128Call {
	c_.Call.Do(f)
	return c_
}

//   AddComplex64(key string, value complex64)
func (r_ *MockZapEncoderMockRecorder) AddComplex64(key interface{}, value interface{}) MockZapEncoderAddComplex64Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddComplex64", reflect.TypeOf((*MockZapEncoder)(nil).AddComplex64), key, value)
	return MockZapEncoderAddComplex64Call{call}
}

// MockZapEncoderAddComplex64Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddComplex64Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddComplex64Call) DoAndReturn(f func(key string, value complex64)) MockZapEncoderAddComplex64Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddComplex64Call) Do(f func(key string, value complex64)) MockZapEncoderAddComplex64Call {
	c_.Call.Do(f)
	return c_
}

//   AddDuration(key string, value time.Duration)
func (r_ *MockZapEncoderMockRecorder) AddDuration(key interface{}, value interface{}) MockZapEncoderAddDurationCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddDuration", reflect.TypeOf((*MockZapEncoder)(nil).AddDuration), key, value)
	return MockZapEncoderAddDurationCall{call}
}

// MockZapEncoderAddDurationCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddDurationCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddDurationCall) DoAndReturn(f func(key string, value time.Duration)) MockZapEncoderAddDurationCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddDurationCall) Do(f func(key string, value time.Duration)) MockZapEncoderAddDurationCall {
	c_.Call.Do(f)
	return c_
}

//   AddFloat32(key string, value float32)
func (r_ *MockZapEncoderMockRecorder) AddFloat32(key interface{}, value interface{}) MockZapEncoderAddFloat32Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddFloat32", reflect.TypeOf((*MockZapEncoder)(nil).AddFloat32), key, value)
	return MockZapEncoderAddFloat32Call{call}
}

// MockZapEncoderAddFloat32Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddFloat32Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddFloat32Call) DoAndReturn(f func(key string, value float32)) MockZapEncoderAddFloat32Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddFloat32Call) Do(f func(key string, value float32)) MockZapEncoderAddFloat32Call {
	c_.Call.Do(f)
	return c_
}

//   AddFloat64(key string, value float64)
func (r_ *MockZapEncoderMockRecorder) AddFloat64(key interface{}, value interface{}) MockZapEncoderAddFloat64Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddFloat64", reflect.TypeOf((*MockZapEncoder)(nil).AddFloat64), key, value)
	return MockZapEncoderAddFloat64Call{call}
}

// MockZapEncoderAddFloat64Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddFloat64Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddFloat64Call) DoAndReturn(f func(key string, value float64)) MockZapEncoderAddFloat64Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddFloat64Call) Do(f func(key string, value float64)) MockZapEncoderAddFloat64Call {
	c_.Call.Do(f)
	return c_
}

//   AddInt(key string, value int)
func (r_ *MockZapEncoderMockRecorder) AddInt(key interface{}, value interface{}) MockZapEncoderAddIntCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddInt", reflect.TypeOf((*MockZapEncoder)(nil).AddInt), key, value)
	return MockZapEncoderAddIntCall{call}
}

// MockZapEncoderAddIntCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddIntCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddIntCall) DoAndReturn(f func(key string, value int)) MockZapEncoderAddIntCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddIntCall) Do(f func(key string, value int)) MockZapEncoderAddIntCall {
	c_.Call.Do(f)
	return c_
}

//   AddInt16(key string, value int16)
func (r_ *MockZapEncoderMockRecorder) AddInt16(key interface{}, value interface{}) MockZapEncoderAddInt16Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddInt16", reflect.TypeOf((*MockZapEncoder)(nil).AddInt16), key, value)
	return MockZapEncoderAddInt16Call{call}
}

// MockZapEncoderAddInt16Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddInt16Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddInt16Call) DoAndReturn(f func(key string, value int16)) MockZapEncoderAddInt16Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddInt16Call) Do(f func(key string, value int16)) MockZapEncoderAddInt16Call {
	c_.Call.Do(f)
	return c_
}

//   AddInt32(key string, value int32)
func (r_ *MockZapEncoderMockRecorder) AddInt32(key interface{}, value interface{}) MockZapEncoderAddInt32Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddInt32", reflect.TypeOf((*MockZapEncoder)(nil).AddInt32), key, value)
	return MockZapEncoderAddInt32Call{call}
}

// MockZapEncoderAddInt32Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddInt32Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddInt32Call) DoAndReturn(f func(key string, value int32)) MockZapEncoderAddInt32Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddInt32Call) Do(f func(key string, value int32)) MockZapEncoderAddInt32Call {
	c_.Call.Do(f)
	return c_
}

//   AddInt64(key string, value int64)
func (r_ *MockZapEncoderMockRecorder) AddInt64(key interface{}, value interface{}) MockZapEncoderAddInt64Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddInt64", reflect.TypeOf((*MockZapEncoder)(nil).AddInt64), key, value)
	return MockZapEncoderAddInt64Call{call}
}

// MockZapEncoderAddInt64Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddInt64Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddInt64Call) DoAndReturn(f func(key string, value int64)) MockZapEncoderAddInt64Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddInt64Call) Do(f func(key string, value int64)) MockZapEncoderAddInt64Call {
	c_.Call.Do(f)
	return c_
}

//   AddInt8(key string, value int8)
func (r_ *MockZapEncoderMockRecorder) AddInt8(key interface{}, value interface{}) MockZapEncoderAddInt8Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddInt8", reflect.TypeOf((*MockZapEncoder)(nil).AddInt8), key, value)
	return MockZapEncoderAddInt8Call{call}
}

// MockZapEncoderAddInt8Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddInt8Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddInt8Call) DoAndReturn(f func(key string, value int8)) MockZapEncoderAddInt8Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddInt8Call) Do(f func(key string, value int8)) MockZapEncoderAddInt8Call {
	c_.Call.Do(f)
	return c_
}

//   AddObject(key string, marshaler zapcore.ObjectMarshaler) error
func (r_ *MockZapEncoderMockRecorder) AddObject(key interface{}, marshaler interface{}) MockZapEncoderAddObjectCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddObject", reflect.TypeOf((*MockZapEncoder)(nil).AddObject), key, marshaler)
	return MockZapEncoderAddObjectCall{call}
}

// MockZapEncoderAddObjectCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddObjectCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddObjectCall) DoAndReturn(f func(key string, marshaler zapcore.ObjectMarshaler) error) MockZapEncoderAddObjectCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddObjectCall) Do(f func(key string, marshaler zapcore.ObjectMarshaler)) MockZapEncoderAddObjectCall {
	c_.Call.Do(f)
	return c_
}

// Return is type safe wrapper of *gomock.Call Return.
func (c_ MockZapEncoderAddObjectCall) Return(res0 error) MockZapEncoderAddObjectCall {
	c_.Call.Return(res0)
	return c_
}

//   AddReflected(key string, value interface{}) error
func (r_ *MockZapEncoderMockRecorder) AddReflected(key interface{}, value interface{}) MockZapEncoderAddReflectedCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddReflected", reflect.TypeOf((*MockZapEncoder)(nil).AddReflected), key, value)
	return MockZapEncoderAddReflectedCall{call}
}

// MockZapEncoderAddReflectedCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddReflectedCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddReflectedCall) DoAndReturn(f func(key string, value interface{}) error) MockZapEncoderAddReflectedCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddReflectedCall) Do(f func(key string, value interface{})) MockZapEncoderAddReflectedCall {
	c_.Call.Do(f)
	return c_
}

// Return is type safe wrapper of *gomock.Call Return.
func (c_ MockZapEncoderAddReflectedCall) Return(res0 error) MockZapEncoderAddReflectedCall {
	c_.Call.Return(res0)
	return c_
}

//   AddString(key string, value string)
func (r_ *MockZapEncoderMockRecorder) AddString(key interface{}, value interface{}) MockZapEncoderAddStringCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddString", reflect.TypeOf((*MockZapEncoder)(nil).AddString), key, value)
	return MockZapEncoderAddStringCall{call}
}

// MockZapEncoderAddStringCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddStringCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddStringCall) DoAndReturn(f func(key string, value string)) MockZapEncoderAddStringCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddStringCall) Do(f func(key string, value string)) MockZapEncoderAddStringCall {
	c_.Call.Do(f)
	return c_
}

//   AddTime(key string, value time.Time)
func (r_ *MockZapEncoderMockRecorder) AddTime(key interface{}, value interface{}) MockZapEncoderAddTimeCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddTime", reflect.TypeOf((*MockZapEncoder)(nil).AddTime), key, value)
	return MockZapEncoderAddTimeCall{call}
}

// MockZapEncoderAddTimeCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddTimeCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddTimeCall) DoAndReturn(f func(key string, value time.Time)) MockZapEncoderAddTimeCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddTimeCall) Do(f func(key string, value time.Time)) MockZapEncoderAddTimeCall {
	c_.Call.Do(f)
	return c_
}

//   AddUint(key string, value uint)
func (r_ *MockZapEncoderMockRecorder) AddUint(key interface{}, value interface{}) MockZapEncoderAddUintCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddUint", reflect.TypeOf((*MockZapEncoder)(nil).AddUint), key, value)
	return MockZapEncoderAddUintCall{call}
}

// MockZapEncoderAddUintCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddUintCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddUintCall) DoAndReturn(f func(key string, value uint)) MockZapEncoderAddUintCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddUintCall) Do(f func(key string, value uint)) MockZapEncoderAddUintCall {
	c_.Call.Do(f)
	return c_
}

//   AddUint16(key string, value uint16)
func (r_ *MockZapEncoderMockRecorder) AddUint16(key interface{}, value interface{}) MockZapEncoderAddUint16Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddUint16", reflect.TypeOf((*MockZapEncoder)(nil).AddUint16), key, value)
	return MockZapEncoderAddUint16Call{call}
}

// MockZapEncoderAddUint16Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddUint16Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddUint16Call) DoAndReturn(f func(key string, value uint16)) MockZapEncoderAddUint16Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddUint16Call) Do(f func(key string, value uint16)) MockZapEncoderAddUint16Call {
	c_.Call.Do(f)
	return c_
}

//   AddUint32(key string, value uint32)
func (r_ *MockZapEncoderMockRecorder) AddUint32(key interface{}, value interface{}) MockZapEncoderAddUint32Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddUint32", reflect.TypeOf((*MockZapEncoder)(nil).AddUint32), key, value)
	return MockZapEncoderAddUint32Call{call}
}

// MockZapEncoderAddUint32Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddUint32Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddUint32Call) DoAndReturn(f func(key string, value uint32)) MockZapEncoderAddUint32Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddUint32Call) Do(f func(key string, value uint32)) MockZapEncoderAddUint32Call {
	c_.Call.Do(f)
	return c_
}

//   AddUint64(key string, value uint64)
func (r_ *MockZapEncoderMockRecorder) AddUint64(key interface{}, value interface{}) MockZapEncoderAddUint64Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddUint64", reflect.TypeOf((*MockZapEncoder)(nil).AddUint64), key, value)
	return MockZapEncoderAddUint64Call{call}
}

// MockZapEncoderAddUint64Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddUint64Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddUint64Call) DoAndReturn(f func(key string, value uint64)) MockZapEncoderAddUint64Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddUint64Call) Do(f func(key string, value uint64)) MockZapEncoderAddUint64Call {
	c_.Call.Do(f)
	return c_
}

//   AddUint8(key string, value uint8)
func (r_ *MockZapEncoderMockRecorder) AddUint8(key interface{}, value interface{}) MockZapEncoderAddUint8Call {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddUint8", reflect.TypeOf((*MockZapEncoder)(nil).AddUint8), key, value)
	return MockZapEncoderAddUint8Call{call}
}

// MockZapEncoderAddUint8Call is type safe wrapper of *gomock.Call.
type MockZapEncoderAddUint8Call struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddUint8Call) DoAndReturn(f func(key string, value uint8)) MockZapEncoderAddUint8Call {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddUint8Call) Do(f func(key string, value uint8)) MockZapEncoderAddUint8Call {
	c_.Call.Do(f)
	return c_
}

//   AddUintptr(key string, value uintptr)
func (r_ *MockZapEncoderMockRecorder) AddUintptr(key interface{}, value interface{}) MockZapEncoderAddUintptrCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "AddUintptr", reflect.TypeOf((*MockZapEncoder)(nil).AddUintptr), key, value)
	return MockZapEncoderAddUintptrCall{call}
}

// MockZapEncoderAddUintptrCall is type safe wrapper of *gomock.Call.
type MockZapEncoderAddUintptrCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderAddUintptrCall) DoAndReturn(f func(key string, value uintptr)) MockZapEncoderAddUintptrCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderAddUintptrCall) Do(f func(key string, value uintptr)) MockZapEncoderAddUintptrCall {
	c_.Call.Do(f)
	return c_
}

//   Clone() zapcore.Encoder
func (r_ *MockZapEncoderMockRecorder) Clone() MockZapEncoderCloneCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "Clone", reflect.TypeOf((*MockZapEncoder)(nil).Clone))
	return MockZapEncoderCloneCall{call}
}

// MockZapEncoderCloneCall is type safe wrapper of *gomock.Call.
type MockZapEncoderCloneCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderCloneCall) DoAndReturn(f func() zapcore.Encoder) MockZapEncoderCloneCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderCloneCall) Do(f func()) MockZapEncoderCloneCall {
	c_.Call.Do(f)
	return c_
}

// Return is type safe wrapper of *gomock.Call Return.
func (c_ MockZapEncoderCloneCall) Return(res0 zapcore.Encoder) MockZapEncoderCloneCall {
	c_.Call.Return(res0)
	return c_
}

//   EncodeEntry(zapcore.Entry, []zapcore.Field) (*buffer.Buffer, error)
func (r_ *MockZapEncoderMockRecorder) EncodeEntry(arg interface{}, arg2 interface{}) MockZapEncoderEncodeEntryCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "EncodeEntry", reflect.TypeOf((*MockZapEncoder)(nil).EncodeEntry), arg, arg2)
	return MockZapEncoderEncodeEntryCall{call}
}

// MockZapEncoderEncodeEntryCall is type safe wrapper of *gomock.Call.
type MockZapEncoderEncodeEntryCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderEncodeEntryCall) DoAndReturn(f func(arg zapcore.Entry, arg2 []zapcore.Field) (*buffer.Buffer, error)) MockZapEncoderEncodeEntryCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderEncodeEntryCall) Do(f func(arg zapcore.Entry, arg2 []zapcore.Field)) MockZapEncoderEncodeEntryCall {
	c_.Call.Do(f)
	return c_
}

// Return is type safe wrapper of *gomock.Call Return.
func (c_ MockZapEncoderEncodeEntryCall) Return(res0 *buffer.Buffer, res1 error) MockZapEncoderEncodeEntryCall {
	c_.Call.Return(res0, res1)
	return c_
}

//   OpenNamespace(key string)
func (r_ *MockZapEncoderMockRecorder) OpenNamespace(key interface{}) MockZapEncoderOpenNamespaceCall {
	r_.ctrl.T.Helper()
	call := r_.ctrl.RecordCallWithMethodType(r_.mock(), "OpenNamespace", reflect.TypeOf((*MockZapEncoder)(nil).OpenNamespace), key)
	return MockZapEncoderOpenNamespaceCall{call}
}

// MockZapEncoderOpenNamespaceCall is type safe wrapper of *gomock.Call.
type MockZapEncoderOpenNamespaceCall struct{ *gomock.Call }

// DoAndReturn is type safe wrapper of *gomock.Call DoAndReturn.
func (c_ MockZapEncoderOpenNamespaceCall) DoAndReturn(f func(key string)) MockZapEncoderOpenNamespaceCall {
	c_.Call.DoAndReturn(f)
	return c_
}

// Do is type safe wrapper of *gomock.Call Do.
func (c_ MockZapEncoderOpenNamespaceCall) Do(f func(key string)) MockZapEncoderOpenNamespaceCall {
	c_.Call.Do(f)
	return c_
}

func (r_ *MockZapEncoderMockRecorder) mock() *MockZapEncoder {
	return (*MockZapEncoder)(r_)
}