common/persistence/serializer_mock.go

// The MIT License (MIT)

// Copyright (c) 2017-2020 Uber Technologies Inc.

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/uber/cadence/common/persistence (interfaces: PayloadSerializer)

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"

	common "github.com/uber/cadence/common"
	checksum "github.com/uber/cadence/common/checksum"
	types "github.com/uber/cadence/common/types"
)

// MockPayloadSerializer is a mock of PayloadSerializer interface.
type MockPayloadSerializer struct {
	ctrl     *gomock.Controller
	recorder *MockPayloadSerializerMockRecorder
}

// MockPayloadSerializerMockRecorder is the mock recorder for MockPayloadSerializer.
type MockPayloadSerializerMockRecorder struct {
	mock *MockPayloadSerializer
}

// NewMockPayloadSerializer creates a new mock instance.
func NewMockPayloadSerializer(ctrl *gomock.Controller) *MockPayloadSerializer {
	mock := &MockPayloadSerializer{ctrl: ctrl}
	mock.recorder = &MockPayloadSerializerMockRecorder{mock}
	return mock
}

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

// DeserializeAsyncWorkflowsConfig mocks base method.
func (m *MockPayloadSerializer) DeserializeAsyncWorkflowsConfig(arg0 *DataBlob) (*types.AsyncWorkflowConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeAsyncWorkflowsConfig", arg0)
	ret0, _ := ret[0].(*types.AsyncWorkflowConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeAsyncWorkflowsConfig indicates an expected call of DeserializeAsyncWorkflowsConfig.
func (mr *MockPayloadSerializerMockRecorder) DeserializeAsyncWorkflowsConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeAsyncWorkflowsConfig", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeAsyncWorkflowsConfig), arg0)
}

// DeserializeBadBinaries mocks base method.
func (m *MockPayloadSerializer) DeserializeBadBinaries(arg0 *DataBlob) (*types.BadBinaries, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeBadBinaries", arg0)
	ret0, _ := ret[0].(*types.BadBinaries)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeBadBinaries indicates an expected call of DeserializeBadBinaries.
func (mr *MockPayloadSerializerMockRecorder) DeserializeBadBinaries(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeBadBinaries", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeBadBinaries), arg0)
}

// DeserializeBatchEvents mocks base method.
func (m *MockPayloadSerializer) DeserializeBatchEvents(arg0 *DataBlob) ([]*types.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeBatchEvents", arg0)
	ret0, _ := ret[0].([]*types.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeBatchEvents indicates an expected call of DeserializeBatchEvents.
func (mr *MockPayloadSerializerMockRecorder) DeserializeBatchEvents(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeBatchEvents", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeBatchEvents), arg0)
}

// DeserializeChecksum mocks base method.
func (m *MockPayloadSerializer) DeserializeChecksum(arg0 *DataBlob) (checksum.Checksum, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeChecksum", arg0)
	ret0, _ := ret[0].(checksum.Checksum)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeChecksum indicates an expected call of DeserializeChecksum.
func (mr *MockPayloadSerializerMockRecorder) DeserializeChecksum(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeChecksum", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeChecksum), arg0)
}

// DeserializeDynamicConfigBlob mocks base method.
func (m *MockPayloadSerializer) DeserializeDynamicConfigBlob(arg0 *DataBlob) (*types.DynamicConfigBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeDynamicConfigBlob", arg0)
	ret0, _ := ret[0].(*types.DynamicConfigBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeDynamicConfigBlob indicates an expected call of DeserializeDynamicConfigBlob.
func (mr *MockPayloadSerializerMockRecorder) DeserializeDynamicConfigBlob(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeDynamicConfigBlob", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeDynamicConfigBlob), arg0)
}

// DeserializeEvent mocks base method.
func (m *MockPayloadSerializer) DeserializeEvent(arg0 *DataBlob) (*types.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeEvent", arg0)
	ret0, _ := ret[0].(*types.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeEvent indicates an expected call of DeserializeEvent.
func (mr *MockPayloadSerializerMockRecorder) DeserializeEvent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeEvent", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeEvent), arg0)
}

// DeserializeIsolationGroups mocks base method.
func (m *MockPayloadSerializer) DeserializeIsolationGroups(arg0 *DataBlob) (*types.IsolationGroupConfiguration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeIsolationGroups", arg0)
	ret0, _ := ret[0].(*types.IsolationGroupConfiguration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeIsolationGroups indicates an expected call of DeserializeIsolationGroups.
func (mr *MockPayloadSerializerMockRecorder) DeserializeIsolationGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeIsolationGroups", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeIsolationGroups), arg0)
}

// DeserializePendingFailoverMarkers mocks base method.
func (m *MockPayloadSerializer) DeserializePendingFailoverMarkers(arg0 *DataBlob) ([]*types.FailoverMarkerAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializePendingFailoverMarkers", arg0)
	ret0, _ := ret[0].([]*types.FailoverMarkerAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializePendingFailoverMarkers indicates an expected call of DeserializePendingFailoverMarkers.
func (mr *MockPayloadSerializerMockRecorder) DeserializePendingFailoverMarkers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializePendingFailoverMarkers", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializePendingFailoverMarkers), arg0)
}

// DeserializeProcessingQueueStates mocks base method.
func (m *MockPayloadSerializer) DeserializeProcessingQueueStates(arg0 *DataBlob) (*types.ProcessingQueueStates, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeProcessingQueueStates", arg0)
	ret0, _ := ret[0].(*types.ProcessingQueueStates)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeProcessingQueueStates indicates an expected call of DeserializeProcessingQueueStates.
func (mr *MockPayloadSerializerMockRecorder) DeserializeProcessingQueueStates(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeProcessingQueueStates", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeProcessingQueueStates), arg0)
}

// DeserializeResetPoints mocks base method.
func (m *MockPayloadSerializer) DeserializeResetPoints(arg0 *DataBlob) (*types.ResetPoints, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeResetPoints", arg0)
	ret0, _ := ret[0].(*types.ResetPoints)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeResetPoints indicates an expected call of DeserializeResetPoints.
func (mr *MockPayloadSerializerMockRecorder) DeserializeResetPoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeResetPoints", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeResetPoints), arg0)
}

// DeserializeVersionHistories mocks base method.
func (m *MockPayloadSerializer) DeserializeVersionHistories(arg0 *DataBlob) (*types.VersionHistories, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeVersionHistories", arg0)
	ret0, _ := ret[0].(*types.VersionHistories)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeVersionHistories indicates an expected call of DeserializeVersionHistories.
func (mr *MockPayloadSerializerMockRecorder) DeserializeVersionHistories(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeVersionHistories", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeVersionHistories), arg0)
}

// DeserializeVisibilityMemo mocks base method.
func (m *MockPayloadSerializer) DeserializeVisibilityMemo(arg0 *DataBlob) (*types.Memo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeserializeVisibilityMemo", arg0)
	ret0, _ := ret[0].(*types.Memo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeserializeVisibilityMemo indicates an expected call of DeserializeVisibilityMemo.
func (mr *MockPayloadSerializerMockRecorder) DeserializeVisibilityMemo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeserializeVisibilityMemo", reflect.TypeOf((*MockPayloadSerializer)(nil).DeserializeVisibilityMemo), arg0)
}

// SerializeAsyncWorkflowsConfig mocks base method.
func (m *MockPayloadSerializer) SerializeAsyncWorkflowsConfig(arg0 *types.AsyncWorkflowConfiguration, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeAsyncWorkflowsConfig", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeAsyncWorkflowsConfig indicates an expected call of SerializeAsyncWorkflowsConfig.
func (mr *MockPayloadSerializerMockRecorder) SerializeAsyncWorkflowsConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeAsyncWorkflowsConfig", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeAsyncWorkflowsConfig), arg0, arg1)
}

// SerializeBadBinaries mocks base method.
func (m *MockPayloadSerializer) SerializeBadBinaries(arg0 *types.BadBinaries, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeBadBinaries", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeBadBinaries indicates an expected call of SerializeBadBinaries.
func (mr *MockPayloadSerializerMockRecorder) SerializeBadBinaries(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeBadBinaries", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeBadBinaries), arg0, arg1)
}

// SerializeBatchEvents mocks base method.
func (m *MockPayloadSerializer) SerializeBatchEvents(arg0 []*types.HistoryEvent, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeBatchEvents", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeBatchEvents indicates an expected call of SerializeBatchEvents.
func (mr *MockPayloadSerializerMockRecorder) SerializeBatchEvents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeBatchEvents", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeBatchEvents), arg0, arg1)
}

// SerializeChecksum mocks base method.
func (m *MockPayloadSerializer) SerializeChecksum(arg0 checksum.Checksum, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeChecksum", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeChecksum indicates an expected call of SerializeChecksum.
func (mr *MockPayloadSerializerMockRecorder) SerializeChecksum(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeChecksum", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeChecksum), arg0, arg1)
}

// SerializeDynamicConfigBlob mocks base method.
func (m *MockPayloadSerializer) SerializeDynamicConfigBlob(arg0 *types.DynamicConfigBlob, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeDynamicConfigBlob", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeDynamicConfigBlob indicates an expected call of SerializeDynamicConfigBlob.
func (mr *MockPayloadSerializerMockRecorder) SerializeDynamicConfigBlob(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeDynamicConfigBlob", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeDynamicConfigBlob), arg0, arg1)
}

// SerializeEvent mocks base method.
func (m *MockPayloadSerializer) SerializeEvent(arg0 *types.HistoryEvent, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeEvent", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeEvent indicates an expected call of SerializeEvent.
func (mr *MockPayloadSerializerMockRecorder) SerializeEvent(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeEvent", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeEvent), arg0, arg1)
}

// SerializeIsolationGroups mocks base method.
func (m *MockPayloadSerializer) SerializeIsolationGroups(arg0 *types.IsolationGroupConfiguration, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeIsolationGroups", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeIsolationGroups indicates an expected call of SerializeIsolationGroups.
func (mr *MockPayloadSerializerMockRecorder) SerializeIsolationGroups(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeIsolationGroups", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeIsolationGroups), arg0, arg1)
}

// SerializePendingFailoverMarkers mocks base method.
func (m *MockPayloadSerializer) SerializePendingFailoverMarkers(arg0 []*types.FailoverMarkerAttributes, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializePendingFailoverMarkers", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializePendingFailoverMarkers indicates an expected call of SerializePendingFailoverMarkers.
func (mr *MockPayloadSerializerMockRecorder) SerializePendingFailoverMarkers(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializePendingFailoverMarkers", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializePendingFailoverMarkers), arg0, arg1)
}

// SerializeProcessingQueueStates mocks base method.
func (m *MockPayloadSerializer) SerializeProcessingQueueStates(arg0 *types.ProcessingQueueStates, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeProcessingQueueStates", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeProcessingQueueStates indicates an expected call of SerializeProcessingQueueStates.
func (mr *MockPayloadSerializerMockRecorder) SerializeProcessingQueueStates(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeProcessingQueueStates", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeProcessingQueueStates), arg0, arg1)
}

// SerializeResetPoints mocks base method.
func (m *MockPayloadSerializer) SerializeResetPoints(arg0 *types.ResetPoints, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeResetPoints", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeResetPoints indicates an expected call of SerializeResetPoints.
func (mr *MockPayloadSerializerMockRecorder) SerializeResetPoints(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeResetPoints", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeResetPoints), arg0, arg1)
}

// SerializeVersionHistories mocks base method.
func (m *MockPayloadSerializer) SerializeVersionHistories(arg0 *types.VersionHistories, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeVersionHistories", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeVersionHistories indicates an expected call of SerializeVersionHistories.
func (mr *MockPayloadSerializerMockRecorder) SerializeVersionHistories(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeVersionHistories", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeVersionHistories), arg0, arg1)
}

// SerializeVisibilityMemo mocks base method.
func (m *MockPayloadSerializer) SerializeVisibilityMemo(arg0 *types.Memo, arg1 common.EncodingType) (*DataBlob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SerializeVisibilityMemo", arg0, arg1)
	ret0, _ := ret[0].(*DataBlob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SerializeVisibilityMemo indicates an expected call of SerializeVisibilityMemo.
func (mr *MockPayloadSerializerMockRecorder) SerializeVisibilityMemo(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializeVisibilityMemo", reflect.TypeOf((*MockPayloadSerializer)(nil).SerializeVisibilityMemo), arg0, arg1)
}