any2anexoj/internal/mocks/mocks_gen.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/nmoniz/any2anexoj/internal (interfaces: RecordReader,Record,ReportWriter,RecordEncoder,RecordDecoder,RecordSerializer)
//
// Generated by this command:
//
//	mockgen -destination=mocks/mocks_gen.go -package=mocks -typed . RecordReader,Record,ReportWriter,RecordEncoder,RecordDecoder,RecordSerializer
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	internal "github.com/nmoniz/any2anexoj/internal"
	decimal "github.com/shopspring/decimal"
	gomock "go.uber.org/mock/gomock"
)

// MockRecordReader is a mock of RecordReader interface.
type MockRecordReader struct {
	ctrl     *gomock.Controller
	recorder *MockRecordReaderMockRecorder
	isgomock struct{}
}

// MockRecordReaderMockRecorder is the mock recorder for MockRecordReader.
type MockRecordReaderMockRecorder struct {
	mock *MockRecordReader
}

// NewMockRecordReader creates a new mock instance.
func NewMockRecordReader(ctrl *gomock.Controller) *MockRecordReader {
	mock := &MockRecordReader{ctrl: ctrl}
	mock.recorder = &MockRecordReaderMockRecorder{mock}
	return mock
}

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

// ReadRecord mocks base method.
func (m *MockRecordReader) ReadRecord(arg0 context.Context) (internal.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadRecord", arg0)
	ret0, _ := ret[0].(internal.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadRecord indicates an expected call of ReadRecord.
func (mr *MockRecordReaderMockRecorder) ReadRecord(arg0 any) *MockRecordReaderReadRecordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRecord", reflect.TypeOf((*MockRecordReader)(nil).ReadRecord), arg0)
	return &MockRecordReaderReadRecordCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordReaderReadRecordCall) Return(arg0 internal.Record, arg1 error) *MockRecordReaderReadRecordCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordReaderReadRecordCall) Do(f func(context.Context) (internal.Record, error)) *MockRecordReaderReadRecordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordReaderReadRecordCall) DoAndReturn(f func(context.Context) (internal.Record, error)) *MockRecordReaderReadRecordCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRecord is a mock of Record interface.
type MockRecord struct {
	ctrl     *gomock.Controller
	recorder *MockRecordMockRecorder
	isgomock struct{}
}

// MockRecordMockRecorder is the mock recorder for MockRecord.
type MockRecordMockRecorder struct {
	mock *MockRecord
}

// NewMockRecord creates a new mock instance.
func NewMockRecord(ctrl *gomock.Controller) *MockRecord {
	mock := &MockRecord{ctrl: ctrl}
	mock.recorder = &MockRecordMockRecorder{mock}
	return mock
}

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

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

// AssetCountry indicates an expected call of AssetCountry.
func (mr *MockRecordMockRecorder) AssetCountry() *MockRecordAssetCountryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetCountry", reflect.TypeOf((*MockRecord)(nil).AssetCountry))
	return &MockRecordAssetCountryCall{Call: call}
}

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

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

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

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

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

// BrokerCountry indicates an expected call of BrokerCountry.
func (mr *MockRecordMockRecorder) BrokerCountry() *MockRecordBrokerCountryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BrokerCountry", reflect.TypeOf((*MockRecord)(nil).BrokerCountry))
	return &MockRecordBrokerCountryCall{Call: call}
}

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

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

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

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

// Fees mocks base method.
func (m *MockRecord) Fees() decimal.Decimal {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fees")
	ret0, _ := ret[0].(decimal.Decimal)
	return ret0
}

// Fees indicates an expected call of Fees.
func (mr *MockRecordMockRecorder) Fees() *MockRecordFeesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fees", reflect.TypeOf((*MockRecord)(nil).Fees))
	return &MockRecordFeesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordFeesCall) Return(arg0 decimal.Decimal) *MockRecordFeesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// Kind indicates an expected call of Kind.
func (mr *MockRecordMockRecorder) Kind() *MockRecordKindCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kind", reflect.TypeOf((*MockRecord)(nil).Kind))
	return &MockRecordKindCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordKindCall) Return(arg0 internal.Kind) *MockRecordKindCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// Nature indicates an expected call of Nature.
func (mr *MockRecordMockRecorder) Nature() *MockRecordNatureCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nature", reflect.TypeOf((*MockRecord)(nil).Nature))
	return &MockRecordNatureCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordNatureCall) Return(arg0 internal.Nature) *MockRecordNatureCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// Price mocks base method.
func (m *MockRecord) Price() decimal.Decimal {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Price")
	ret0, _ := ret[0].(decimal.Decimal)
	return ret0
}

// Price indicates an expected call of Price.
func (mr *MockRecordMockRecorder) Price() *MockRecordPriceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Price", reflect.TypeOf((*MockRecord)(nil).Price))
	return &MockRecordPriceCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordPriceCall) Return(arg0 decimal.Decimal) *MockRecordPriceCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// Quantity mocks base method.
func (m *MockRecord) Quantity() decimal.Decimal {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Quantity")
	ret0, _ := ret[0].(decimal.Decimal)
	return ret0
}

// Quantity indicates an expected call of Quantity.
func (mr *MockRecordMockRecorder) Quantity() *MockRecordQuantityCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quantity", reflect.TypeOf((*MockRecord)(nil).Quantity))
	return &MockRecordQuantityCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordQuantityCall) Return(arg0 decimal.Decimal) *MockRecordQuantityCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// Symbol indicates an expected call of Symbol.
func (mr *MockRecordMockRecorder) Symbol() *MockRecordSymbolCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Symbol", reflect.TypeOf((*MockRecord)(nil).Symbol))
	return &MockRecordSymbolCall{Call: call}
}

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

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

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

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

// Taxes mocks base method.
func (m *MockRecord) Taxes() decimal.Decimal {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Taxes")
	ret0, _ := ret[0].(decimal.Decimal)
	return ret0
}

// Taxes indicates an expected call of Taxes.
func (mr *MockRecordMockRecorder) Taxes() *MockRecordTaxesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Taxes", reflect.TypeOf((*MockRecord)(nil).Taxes))
	return &MockRecordTaxesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordTaxesCall) Return(arg0 decimal.Decimal) *MockRecordTaxesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// Timestamp mocks base method.
func (m *MockRecord) Timestamp() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Timestamp")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// Timestamp indicates an expected call of Timestamp.
func (mr *MockRecordMockRecorder) Timestamp() *MockRecordTimestampCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockRecord)(nil).Timestamp))
	return &MockRecordTimestampCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordTimestampCall) Return(arg0 time.Time) *MockRecordTimestampCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// MockReportWriter is a mock of ReportWriter interface.
type MockReportWriter struct {
	ctrl     *gomock.Controller
	recorder *MockReportWriterMockRecorder
	isgomock struct{}
}

// MockReportWriterMockRecorder is the mock recorder for MockReportWriter.
type MockReportWriterMockRecorder struct {
	mock *MockReportWriter
}

// NewMockReportWriter creates a new mock instance.
func NewMockReportWriter(ctrl *gomock.Controller) *MockReportWriter {
	mock := &MockReportWriter{ctrl: ctrl}
	mock.recorder = &MockReportWriterMockRecorder{mock}
	return mock
}

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

// Write mocks base method.
func (m *MockReportWriter) Write(arg0 context.Context, arg1 internal.ReportItem) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockReportWriterMockRecorder) Write(arg0, arg1 any) *MockReportWriterWriteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockReportWriter)(nil).Write), arg0, arg1)
	return &MockReportWriterWriteCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockReportWriterWriteCall) Do(f func(context.Context, internal.ReportItem) error) *MockReportWriterWriteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockReportWriterWriteCall) DoAndReturn(f func(context.Context, internal.ReportItem) error) *MockReportWriterWriteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRecordEncoder is a mock of RecordEncoder interface.
type MockRecordEncoder struct {
	ctrl     *gomock.Controller
	recorder *MockRecordEncoderMockRecorder
	isgomock struct{}
}

// MockRecordEncoderMockRecorder is the mock recorder for MockRecordEncoder.
type MockRecordEncoderMockRecorder struct {
	mock *MockRecordEncoder
}

// NewMockRecordEncoder creates a new mock instance.
func NewMockRecordEncoder(ctrl *gomock.Controller) *MockRecordEncoder {
	mock := &MockRecordEncoder{ctrl: ctrl}
	mock.recorder = &MockRecordEncoderMockRecorder{mock}
	return mock
}

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

// MarshalRecord mocks base method.
func (m *MockRecordEncoder) MarshalRecord(arg0 context.Context, arg1 internal.Record) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalRecord", arg0, arg1)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarshalRecord indicates an expected call of MarshalRecord.
func (mr *MockRecordEncoderMockRecorder) MarshalRecord(arg0, arg1 any) *MockRecordEncoderMarshalRecordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalRecord", reflect.TypeOf((*MockRecordEncoder)(nil).MarshalRecord), arg0, arg1)
	return &MockRecordEncoderMarshalRecordCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordEncoderMarshalRecordCall) Return(arg0 []byte, arg1 error) *MockRecordEncoderMarshalRecordCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordEncoderMarshalRecordCall) Do(f func(context.Context, internal.Record) ([]byte, error)) *MockRecordEncoderMarshalRecordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordEncoderMarshalRecordCall) DoAndReturn(f func(context.Context, internal.Record) ([]byte, error)) *MockRecordEncoderMarshalRecordCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRecordDecoder is a mock of RecordDecoder interface.
type MockRecordDecoder struct {
	ctrl     *gomock.Controller
	recorder *MockRecordDecoderMockRecorder
	isgomock struct{}
}

// MockRecordDecoderMockRecorder is the mock recorder for MockRecordDecoder.
type MockRecordDecoderMockRecorder struct {
	mock *MockRecordDecoder
}

// NewMockRecordDecoder creates a new mock instance.
func NewMockRecordDecoder(ctrl *gomock.Controller) *MockRecordDecoder {
	mock := &MockRecordDecoder{ctrl: ctrl}
	mock.recorder = &MockRecordDecoderMockRecorder{mock}
	return mock
}

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

// UnmarshalRecord mocks base method.
func (m *MockRecordDecoder) UnmarshalRecord(arg0 context.Context, arg1 []byte) (internal.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnmarshalRecord", arg0, arg1)
	ret0, _ := ret[0].(internal.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnmarshalRecord indicates an expected call of UnmarshalRecord.
func (mr *MockRecordDecoderMockRecorder) UnmarshalRecord(arg0, arg1 any) *MockRecordDecoderUnmarshalRecordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalRecord", reflect.TypeOf((*MockRecordDecoder)(nil).UnmarshalRecord), arg0, arg1)
	return &MockRecordDecoderUnmarshalRecordCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordDecoderUnmarshalRecordCall) Return(arg0 internal.Record, arg1 error) *MockRecordDecoderUnmarshalRecordCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordDecoderUnmarshalRecordCall) Do(f func(context.Context, []byte) (internal.Record, error)) *MockRecordDecoderUnmarshalRecordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordDecoderUnmarshalRecordCall) DoAndReturn(f func(context.Context, []byte) (internal.Record, error)) *MockRecordDecoderUnmarshalRecordCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRecordSerializer is a mock of RecordSerializer interface.
type MockRecordSerializer struct {
	ctrl     *gomock.Controller
	recorder *MockRecordSerializerMockRecorder
	isgomock struct{}
}

// MockRecordSerializerMockRecorder is the mock recorder for MockRecordSerializer.
type MockRecordSerializerMockRecorder struct {
	mock *MockRecordSerializer
}

// NewMockRecordSerializer creates a new mock instance.
func NewMockRecordSerializer(ctrl *gomock.Controller) *MockRecordSerializer {
	mock := &MockRecordSerializer{ctrl: ctrl}
	mock.recorder = &MockRecordSerializerMockRecorder{mock}
	return mock
}

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

// MarshalRecord mocks base method.
func (m *MockRecordSerializer) MarshalRecord(arg0 context.Context, arg1 internal.Record) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalRecord", arg0, arg1)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarshalRecord indicates an expected call of MarshalRecord.
func (mr *MockRecordSerializerMockRecorder) MarshalRecord(arg0, arg1 any) *MockRecordSerializerMarshalRecordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalRecord", reflect.TypeOf((*MockRecordSerializer)(nil).MarshalRecord), arg0, arg1)
	return &MockRecordSerializerMarshalRecordCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordSerializerMarshalRecordCall) Return(arg0 []byte, arg1 error) *MockRecordSerializerMarshalRecordCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordSerializerMarshalRecordCall) Do(f func(context.Context, internal.Record) ([]byte, error)) *MockRecordSerializerMarshalRecordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordSerializerMarshalRecordCall) DoAndReturn(f func(context.Context, internal.Record) ([]byte, error)) *MockRecordSerializerMarshalRecordCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnmarshalRecord mocks base method.
func (m *MockRecordSerializer) UnmarshalRecord(arg0 context.Context, arg1 []byte) (internal.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnmarshalRecord", arg0, arg1)
	ret0, _ := ret[0].(internal.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnmarshalRecord indicates an expected call of UnmarshalRecord.
func (mr *MockRecordSerializerMockRecorder) UnmarshalRecord(arg0, arg1 any) *MockRecordSerializerUnmarshalRecordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalRecord", reflect.TypeOf((*MockRecordSerializer)(nil).UnmarshalRecord), arg0, arg1)
	return &MockRecordSerializerUnmarshalRecordCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRecordSerializerUnmarshalRecordCall) Return(arg0 internal.Record, arg1 error) *MockRecordSerializerUnmarshalRecordCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordSerializerUnmarshalRecordCall) Do(f func(context.Context, []byte) (internal.Record, error)) *MockRecordSerializerUnmarshalRecordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordSerializerUnmarshalRecordCall) DoAndReturn(f func(context.Context, []byte) (internal.Record, error)) *MockRecordSerializerUnmarshalRecordCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}