// Code generated by MockGen. DO NOT EDIT.
// Source: /Users/chris/go/pkg/mod/github.com/cosmos/cosmos-sdk@v0.50.9/codec/types/interface_registry.go

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

import (
	reflect "reflect"

	signing "cosmossdk.io/x/tx/signing"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	proto "github.com/cosmos/gogoproto/proto"
	gomock "go.uber.org/mock/gomock"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
)

// MockAnyUnpacker is a mock of AnyUnpacker interface.
type MockAnyUnpacker struct {
	ctrl     *gomock.Controller
	recorder *MockAnyUnpackerMockRecorder
}

// MockAnyUnpackerMockRecorder is the mock recorder for MockAnyUnpacker.
type MockAnyUnpackerMockRecorder struct {
	mock *MockAnyUnpacker
}

// NewMockAnyUnpacker creates a new mock instance.
func NewMockAnyUnpacker(ctrl *gomock.Controller) *MockAnyUnpacker {
	mock := &MockAnyUnpacker{ctrl: ctrl}
	mock.recorder = &MockAnyUnpackerMockRecorder{mock}
	return mock
}

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

// UnpackAny mocks base method.
func (m *MockAnyUnpacker) UnpackAny(any *types.Any, iface interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnpackAny", any, iface)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnpackAny indicates an expected call of UnpackAny.
func (mr *MockAnyUnpackerMockRecorder) UnpackAny(any, iface interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackAny", reflect.TypeOf((*MockAnyUnpacker)(nil).UnpackAny), any, iface)
}

// MockInterfaceRegistry is a mock of InterfaceRegistry interface.
type MockInterfaceRegistry struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceRegistryMockRecorder
}

// MockInterfaceRegistryMockRecorder is the mock recorder for MockInterfaceRegistry.
type MockInterfaceRegistryMockRecorder struct {
	mock *MockInterfaceRegistry
}

// NewMockInterfaceRegistry creates a new mock instance.
func NewMockInterfaceRegistry(ctrl *gomock.Controller) *MockInterfaceRegistry {
	mock := &MockInterfaceRegistry{ctrl: ctrl}
	mock.recorder = &MockInterfaceRegistryMockRecorder{mock}
	return mock
}

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

// EnsureRegistered mocks base method.
func (m *MockInterfaceRegistry) EnsureRegistered(iface interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureRegistered", iface)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnsureRegistered indicates an expected call of EnsureRegistered.
func (mr *MockInterfaceRegistryMockRecorder) EnsureRegistered(iface interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureRegistered", reflect.TypeOf((*MockInterfaceRegistry)(nil).EnsureRegistered), iface)
}

// FindDescriptorByName mocks base method.
func (m *MockInterfaceRegistry) FindDescriptorByName(arg0 protoreflect.FullName) (protoreflect.Descriptor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindDescriptorByName", arg0)
	ret0, _ := ret[0].(protoreflect.Descriptor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindFileByPath mocks base method.
func (m *MockInterfaceRegistry) FindFileByPath(arg0 string) (protoreflect.FileDescriptor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindFileByPath", arg0)
	ret0, _ := ret[0].(protoreflect.FileDescriptor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

// ListImplementations indicates an expected call of ListImplementations.
func (mr *MockInterfaceRegistryMockRecorder) ListImplementations(ifaceTypeURL interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImplementations", reflect.TypeOf((*MockInterfaceRegistry)(nil).ListImplementations), ifaceTypeURL)
}

// RangeFiles mocks base method.
func (m *MockInterfaceRegistry) RangeFiles(f func(protoreflect.FileDescriptor) bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RangeFiles", f)
}

// RangeFiles indicates an expected call of RangeFiles.
func (mr *MockInterfaceRegistryMockRecorder) RangeFiles(f interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeFiles", reflect.TypeOf((*MockInterfaceRegistry)(nil).RangeFiles), f)
}

// RegisterImplementations mocks base method.
func (m *MockInterfaceRegistry) RegisterImplementations(iface interface{}, impls ...proto.Message) {
	m.ctrl.T.Helper()
	varargs := []interface{}{iface}
	for _, a := range impls {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "RegisterImplementations", varargs...)
}

// RegisterImplementations indicates an expected call of RegisterImplementations.
func (mr *MockInterfaceRegistryMockRecorder) RegisterImplementations(iface interface{}, impls ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{iface}, impls...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImplementations", reflect.TypeOf((*MockInterfaceRegistry)(nil).RegisterImplementations), varargs...)
}

// RegisterInterface mocks base method.
func (m *MockInterfaceRegistry) RegisterInterface(protoName string, iface interface{}, impls ...proto.Message) {
	m.ctrl.T.Helper()
	varargs := []interface{}{protoName, iface}
	for _, a := range impls {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "RegisterInterface", varargs...)
}

// RegisterInterface indicates an expected call of RegisterInterface.
func (mr *MockInterfaceRegistryMockRecorder) RegisterInterface(protoName, iface interface{}, impls ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{protoName, iface}, impls...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInterface", reflect.TypeOf((*MockInterfaceRegistry)(nil).RegisterInterface), varargs...)
}

// Resolve mocks base method.
func (m *MockInterfaceRegistry) Resolve(typeUrl string) (proto.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resolve", typeUrl)
	ret0, _ := ret[0].(proto.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Resolve indicates an expected call of Resolve.
func (mr *MockInterfaceRegistryMockRecorder) Resolve(typeUrl interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockInterfaceRegistry)(nil).Resolve), typeUrl)
}

// SigningContext mocks base method.
func (m *MockInterfaceRegistry) SigningContext() *signing.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SigningContext")
	ret0, _ := ret[0].(*signing.Context)
	return ret0
}

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

// UnpackAny mocks base method.
func (m *MockInterfaceRegistry) UnpackAny(any *types.Any, iface interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnpackAny", any, iface)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnpackAny indicates an expected call of UnpackAny.
func (mr *MockInterfaceRegistryMockRecorder) UnpackAny(any, iface interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackAny", reflect.TypeOf((*MockInterfaceRegistry)(nil).UnpackAny), any, iface)
}

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

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

// MockUnpackInterfacesMessage is a mock of UnpackInterfacesMessage interface.
type MockUnpackInterfacesMessage struct {
	ctrl     *gomock.Controller
	recorder *MockUnpackInterfacesMessageMockRecorder
}

// MockUnpackInterfacesMessageMockRecorder is the mock recorder for MockUnpackInterfacesMessage.
type MockUnpackInterfacesMessageMockRecorder struct {
	mock *MockUnpackInterfacesMessage
}

// NewMockUnpackInterfacesMessage creates a new mock instance.
func NewMockUnpackInterfacesMessage(ctrl *gomock.Controller) *MockUnpackInterfacesMessage {
	mock := &MockUnpackInterfacesMessage{ctrl: ctrl}
	mock.recorder = &MockUnpackInterfacesMessageMockRecorder{mock}
	return mock
}

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

// UnpackInterfaces mocks base method.
func (m *MockUnpackInterfacesMessage) UnpackInterfaces(unpacker types.AnyUnpacker) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnpackInterfaces", unpacker)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnpackInterfaces indicates an expected call of UnpackInterfaces.
func (mr *MockUnpackInterfacesMessageMockRecorder) UnpackInterfaces(unpacker interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackInterfaces", reflect.TypeOf((*MockUnpackInterfacesMessage)(nil).UnpackInterfaces), unpacker)
}
