common/persistence/serialization/interfaces_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: interfaces.go

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	stream "go.uber.org/thriftrw/protocol/stream"
	wire "go.uber.org/thriftrw/wire"

	common "github.com/uber/cadence/common"
	persistence "github.com/uber/cadence/common/persistence"
)

// MockParser is a mock of Parser interface.
type MockParser struct {
	ctrl     *gomock.Controller
	recorder *MockParserMockRecorder
}

// MockParserMockRecorder is the mock recorder for MockParser.
type MockParserMockRecorder struct {
	mock *MockParser
}

// NewMockParser creates a new mock instance.
func NewMockParser(ctrl *gomock.Controller) *MockParser {
	mock := &MockParser{ctrl: ctrl}
	mock.recorder = &MockParserMockRecorder{mock}
	return mock
}

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

// ActivityInfoFromBlob mocks base method.
func (m *MockParser) ActivityInfoFromBlob(arg0 []byte, arg1 string) (*ActivityInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActivityInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*ActivityInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ChildExecutionInfoFromBlob mocks base method.
func (m *MockParser) ChildExecutionInfoFromBlob(arg0 []byte, arg1 string) (*ChildExecutionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChildExecutionInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*ChildExecutionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CrossClusterTaskInfoFromBlob mocks base method.
func (m *MockParser) CrossClusterTaskInfoFromBlob(arg0 []byte, arg1 string) (*CrossClusterTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CrossClusterTaskInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*CrossClusterTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// DomainInfoFromBlob mocks base method.
func (m *MockParser) DomainInfoFromBlob(arg0 []byte, arg1 string) (*DomainInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DomainInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*DomainInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// HistoryTreeInfoFromBlob mocks base method.
func (m *MockParser) HistoryTreeInfoFromBlob(arg0 []byte, arg1 string) (*HistoryTreeInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HistoryTreeInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*HistoryTreeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ReplicationTaskInfoFromBlob mocks base method.
func (m *MockParser) ReplicationTaskInfoFromBlob(arg0 []byte, arg1 string) (*ReplicationTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplicationTaskInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*ReplicationTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// RequestCancelInfoFromBlob mocks base method.
func (m *MockParser) RequestCancelInfoFromBlob(arg0 []byte, arg1 string) (*RequestCancelInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestCancelInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*RequestCancelInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ShardInfoFromBlob mocks base method.
func (m *MockParser) ShardInfoFromBlob(arg0 []byte, arg1 string) (*ShardInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShardInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*ShardInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SignalInfoFromBlob mocks base method.
func (m *MockParser) SignalInfoFromBlob(arg0 []byte, arg1 string) (*SignalInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignalInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*SignalInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// TaskInfoFromBlob mocks base method.
func (m *MockParser) TaskInfoFromBlob(arg0 []byte, arg1 string) (*TaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TaskInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*TaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// TaskListInfoFromBlob mocks base method.
func (m *MockParser) TaskListInfoFromBlob(arg0 []byte, arg1 string) (*TaskListInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TaskListInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*TaskListInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// TimerInfoFromBlob mocks base method.
func (m *MockParser) TimerInfoFromBlob(arg0 []byte, arg1 string) (*TimerInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TimerInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*TimerInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// TimerTaskInfoFromBlob mocks base method.
func (m *MockParser) TimerTaskInfoFromBlob(arg0 []byte, arg1 string) (*TimerTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TimerTaskInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*TimerTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// TransferTaskInfoFromBlob mocks base method.
func (m *MockParser) TransferTaskInfoFromBlob(arg0 []byte, arg1 string) (*TransferTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferTaskInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*TransferTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// WorkflowExecutionInfoFromBlob mocks base method.
func (m *MockParser) WorkflowExecutionInfoFromBlob(arg0 []byte, arg1 string) (*WorkflowExecutionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WorkflowExecutionInfoFromBlob", arg0, arg1)
	ret0, _ := ret[0].(*WorkflowExecutionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Mockencoder is a mock of encoder interface.
type Mockencoder struct {
	ctrl     *gomock.Controller
	recorder *MockencoderMockRecorder
}

// MockencoderMockRecorder is the mock recorder for Mockencoder.
type MockencoderMockRecorder struct {
	mock *Mockencoder
}

// NewMockencoder creates a new mock instance.
func NewMockencoder(ctrl *gomock.Controller) *Mockencoder {
	mock := &Mockencoder{ctrl: ctrl}
	mock.recorder = &MockencoderMockRecorder{mock}
	return mock
}

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

// activityInfoToBlob mocks base method.
func (m *Mockencoder) activityInfoToBlob(arg0 *ActivityInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "activityInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// childExecutionInfoToBlob mocks base method.
func (m *Mockencoder) childExecutionInfoToBlob(arg0 *ChildExecutionInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "childExecutionInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// crossClusterTaskInfoToBlob mocks base method.
func (m *Mockencoder) crossClusterTaskInfoToBlob(arg0 *CrossClusterTaskInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "crossClusterTaskInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// domainInfoToBlob mocks base method.
func (m *Mockencoder) domainInfoToBlob(arg0 *DomainInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "domainInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// encodingType mocks base method.
func (m *Mockencoder) encodingType() common.EncodingType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "encodingType")
	ret0, _ := ret[0].(common.EncodingType)
	return ret0
}

// encodingType indicates an expected call of encodingType.
func (mr *MockencoderMockRecorder) encodingType() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "encodingType", reflect.TypeOf((*Mockencoder)(nil).encodingType))
}

// historyTreeInfoToBlob mocks base method.
func (m *Mockencoder) historyTreeInfoToBlob(arg0 *HistoryTreeInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "historyTreeInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// replicationTaskInfoToBlob mocks base method.
func (m *Mockencoder) replicationTaskInfoToBlob(arg0 *ReplicationTaskInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "replicationTaskInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// requestCancelInfoToBlob mocks base method.
func (m *Mockencoder) requestCancelInfoToBlob(arg0 *RequestCancelInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "requestCancelInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// shardInfoToBlob mocks base method.
func (m *Mockencoder) shardInfoToBlob(arg0 *ShardInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "shardInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// signalInfoToBlob mocks base method.
func (m *Mockencoder) signalInfoToBlob(arg0 *SignalInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "signalInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// taskInfoToBlob mocks base method.
func (m *Mockencoder) taskInfoToBlob(arg0 *TaskInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "taskInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// taskListInfoToBlob mocks base method.
func (m *Mockencoder) taskListInfoToBlob(arg0 *TaskListInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "taskListInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// timerInfoToBlob mocks base method.
func (m *Mockencoder) timerInfoToBlob(arg0 *TimerInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "timerInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// timerTaskInfoToBlob mocks base method.
func (m *Mockencoder) timerTaskInfoToBlob(arg0 *TimerTaskInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "timerTaskInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// transferTaskInfoToBlob mocks base method.
func (m *Mockencoder) transferTaskInfoToBlob(arg0 *TransferTaskInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "transferTaskInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// workflowExecutionInfoToBlob mocks base method.
func (m *Mockencoder) workflowExecutionInfoToBlob(arg0 *WorkflowExecutionInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "workflowExecutionInfoToBlob", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Mockdecoder is a mock of decoder interface.
type Mockdecoder struct {
	ctrl     *gomock.Controller
	recorder *MockdecoderMockRecorder
}

// MockdecoderMockRecorder is the mock recorder for Mockdecoder.
type MockdecoderMockRecorder struct {
	mock *Mockdecoder
}

// NewMockdecoder creates a new mock instance.
func NewMockdecoder(ctrl *gomock.Controller) *Mockdecoder {
	mock := &Mockdecoder{ctrl: ctrl}
	mock.recorder = &MockdecoderMockRecorder{mock}
	return mock
}

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

// activityInfoFromBlob mocks base method.
func (m *Mockdecoder) activityInfoFromBlob(arg0 []byte) (*ActivityInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "activityInfoFromBlob", arg0)
	ret0, _ := ret[0].(*ActivityInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// childExecutionInfoFromBlob mocks base method.
func (m *Mockdecoder) childExecutionInfoFromBlob(arg0 []byte) (*ChildExecutionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "childExecutionInfoFromBlob", arg0)
	ret0, _ := ret[0].(*ChildExecutionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// crossClusterTaskInfoFromBlob mocks base method.
func (m *Mockdecoder) crossClusterTaskInfoFromBlob(arg0 []byte) (*CrossClusterTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "crossClusterTaskInfoFromBlob", arg0)
	ret0, _ := ret[0].(*CrossClusterTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// domainInfoFromBlob mocks base method.
func (m *Mockdecoder) domainInfoFromBlob(arg0 []byte) (*DomainInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "domainInfoFromBlob", arg0)
	ret0, _ := ret[0].(*DomainInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// historyTreeInfoFromBlob mocks base method.
func (m *Mockdecoder) historyTreeInfoFromBlob(arg0 []byte) (*HistoryTreeInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "historyTreeInfoFromBlob", arg0)
	ret0, _ := ret[0].(*HistoryTreeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// replicationTaskInfoFromBlob mocks base method.
func (m *Mockdecoder) replicationTaskInfoFromBlob(arg0 []byte) (*ReplicationTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "replicationTaskInfoFromBlob", arg0)
	ret0, _ := ret[0].(*ReplicationTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// requestCancelInfoFromBlob mocks base method.
func (m *Mockdecoder) requestCancelInfoFromBlob(arg0 []byte) (*RequestCancelInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "requestCancelInfoFromBlob", arg0)
	ret0, _ := ret[0].(*RequestCancelInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// shardInfoFromBlob mocks base method.
func (m *Mockdecoder) shardInfoFromBlob(arg0 []byte) (*ShardInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "shardInfoFromBlob", arg0)
	ret0, _ := ret[0].(*ShardInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// signalInfoFromBlob mocks base method.
func (m *Mockdecoder) signalInfoFromBlob(arg0 []byte) (*SignalInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "signalInfoFromBlob", arg0)
	ret0, _ := ret[0].(*SignalInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// taskInfoFromBlob mocks base method.
func (m *Mockdecoder) taskInfoFromBlob(arg0 []byte) (*TaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "taskInfoFromBlob", arg0)
	ret0, _ := ret[0].(*TaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// taskListInfoFromBlob mocks base method.
func (m *Mockdecoder) taskListInfoFromBlob(arg0 []byte) (*TaskListInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "taskListInfoFromBlob", arg0)
	ret0, _ := ret[0].(*TaskListInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// timerInfoFromBlob mocks base method.
func (m *Mockdecoder) timerInfoFromBlob(arg0 []byte) (*TimerInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "timerInfoFromBlob", arg0)
	ret0, _ := ret[0].(*TimerInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// timerTaskInfoFromBlob mocks base method.
func (m *Mockdecoder) timerTaskInfoFromBlob(arg0 []byte) (*TimerTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "timerTaskInfoFromBlob", arg0)
	ret0, _ := ret[0].(*TimerTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// transferTaskInfoFromBlob mocks base method.
func (m *Mockdecoder) transferTaskInfoFromBlob(arg0 []byte) (*TransferTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "transferTaskInfoFromBlob", arg0)
	ret0, _ := ret[0].(*TransferTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// workflowExecutionInfoFromBlob mocks base method.
func (m *Mockdecoder) workflowExecutionInfoFromBlob(arg0 []byte) (*WorkflowExecutionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "workflowExecutionInfoFromBlob", arg0)
	ret0, _ := ret[0].(*WorkflowExecutionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockthriftRWType is a mock of thriftRWType interface.
type MockthriftRWType struct {
	ctrl     *gomock.Controller
	recorder *MockthriftRWTypeMockRecorder
}

// MockthriftRWTypeMockRecorder is the mock recorder for MockthriftRWType.
type MockthriftRWTypeMockRecorder struct {
	mock *MockthriftRWType
}

// NewMockthriftRWType creates a new mock instance.
func NewMockthriftRWType(ctrl *gomock.Controller) *MockthriftRWType {
	mock := &MockthriftRWType{ctrl: ctrl}
	mock.recorder = &MockthriftRWTypeMockRecorder{mock}
	return mock
}

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

// Decode mocks base method.
func (m *MockthriftRWType) Decode(arg0 stream.Reader) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Decode", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Encode mocks base method.
func (m *MockthriftRWType) Encode(arg0 stream.Writer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Encode", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// FromWire mocks base method.
func (m *MockthriftRWType) FromWire(w wire.Value) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FromWire", w)
	ret0, _ := ret[0].(error)
	return ret0
}

// FromWire indicates an expected call of FromWire.
func (mr *MockthriftRWTypeMockRecorder) FromWire(w interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FromWire", reflect.TypeOf((*MockthriftRWType)(nil).FromWire), w)
}

// ToWire mocks base method.
func (m *MockthriftRWType) ToWire() (wire.Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ToWire")
	ret0, _ := ret[0].(wire.Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ToWire indicates an expected call of ToWire.
func (mr *MockthriftRWTypeMockRecorder) ToWire() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToWire", reflect.TypeOf((*MockthriftRWType)(nil).ToWire))
}