func (m *MockPubSub_SubscribeServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
SendHeader mocks base method
package mock_proto
import (
	context "context"
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	empty "github.com/golang/protobuf/ptypes/empty"
	proto "github.com/vardius/pubsub/v2/proto"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)
type MockPubSubClient struct {
	ctrl     *gomock.Controller
	recorder *MockPubSubClientMockRecorder
}
type MockPubSubClientMockRecorder struct {
	mock *MockPubSubClient
}
func NewMockPubSubClient(ctrl *gomock.Controller) *MockPubSubClient {
	mock := &MockPubSubClient{ctrl: ctrl}
	mock.recorder = &MockPubSubClientMockRecorder{mock}
	return mock
}
func (m *MockPubSubClient) EXPECT() *MockPubSubClientMockRecorder {
	return m.recorder
}
func (m *MockPubSubClient) Publish(ctx context.Context, in *proto.PublishRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Publish", varargs...)
	ret0, _ := ret[0].(*empty.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPubSubClientMockRecorder) Publish(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockPubSubClient)(nil).Publish), varargs...)
}
func (m *MockPubSubClient) Subscribe(ctx context.Context, in *proto.SubscribeRequest, opts ...grpc.CallOption) (proto.PubSub_SubscribeClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Subscribe", varargs...)
	ret0, _ := ret[0].(proto.PubSub_SubscribeClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPubSubClientMockRecorder) Subscribe(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockPubSubClient)(nil).Subscribe), varargs...)
}
type MockPubSub_SubscribeClient struct {
	ctrl     *gomock.Controller
	recorder *MockPubSub_SubscribeClientMockRecorder
}
type MockPubSub_SubscribeClientMockRecorder struct {
	mock *MockPubSub_SubscribeClient
}
func NewMockPubSub_SubscribeClient(ctrl *gomock.Controller) *MockPubSub_SubscribeClient {
	mock := &MockPubSub_SubscribeClient{ctrl: ctrl}
	mock.recorder = &MockPubSub_SubscribeClientMockRecorder{mock}
	return mock
}
func (m *MockPubSub_SubscribeClient) EXPECT() *MockPubSub_SubscribeClientMockRecorder {
	return m.recorder
}
func (m *MockPubSub_SubscribeClient) Recv() (*proto.SubscribeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*proto.SubscribeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPubSub_SubscribeClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockPubSub_SubscribeClient)(nil).Recv))
}
func (m *MockPubSub_SubscribeClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPubSub_SubscribeClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockPubSub_SubscribeClient)(nil).Header))
}
func (m *MockPubSub_SubscribeClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}
func (mr *MockPubSub_SubscribeClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockPubSub_SubscribeClient)(nil).Trailer))
}
func (m *MockPubSub_SubscribeClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPubSub_SubscribeClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockPubSub_SubscribeClient)(nil).CloseSend))
}
func (m *MockPubSub_SubscribeClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}
func (mr *MockPubSub_SubscribeClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockPubSub_SubscribeClient)(nil).Context))
}
func (m_2 *MockPubSub_SubscribeClient) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPubSub_SubscribeClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockPubSub_SubscribeClient)(nil).SendMsg), m)
}
func (m_2 *MockPubSub_SubscribeClient) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPubSub_SubscribeClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockPubSub_SubscribeClient)(nil).RecvMsg), m)
}
type MockPubSubServer struct {
	ctrl     *gomock.Controller
	recorder *MockPubSubServerMockRecorder
}
type MockPubSubServerMockRecorder struct {
	mock *MockPubSubServer
}
func NewMockPubSubServer(ctrl *gomock.Controller) *MockPubSubServer {
	mock := &MockPubSubServer{ctrl: ctrl}
	mock.recorder = &MockPubSubServerMockRecorder{mock}
	return mock
}
func (m *MockPubSubServer) EXPECT() *MockPubSubServerMockRecorder {
	return m.recorder
}
func (m *MockPubSubServer) Publish(arg0 context.Context, arg1 *proto.PublishRequest) (*empty.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Publish", arg0, arg1)
	ret0, _ := ret[0].(*empty.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPubSubServerMockRecorder) Publish(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockPubSubServer)(nil).Publish), arg0, arg1)
}
func (m *MockPubSubServer) Subscribe(arg0 *proto.SubscribeRequest, arg1 proto.PubSub_SubscribeServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Subscribe", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPubSubServerMockRecorder) Subscribe(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockPubSubServer)(nil).Subscribe), arg0, arg1)
}
type MockPubSub_SubscribeServer struct {
	ctrl     *gomock.Controller
	recorder *MockPubSub_SubscribeServerMockRecorder
}
type MockPubSub_SubscribeServerMockRecorder struct {
	mock *MockPubSub_SubscribeServer
}
func NewMockPubSub_SubscribeServer(ctrl *gomock.Controller) *MockPubSub_SubscribeServer {
	mock := &MockPubSub_SubscribeServer{ctrl: ctrl}
	mock.recorder = &MockPubSub_SubscribeServerMockRecorder{mock}
	return mock
}
func (m *MockPubSub_SubscribeServer) EXPECT() *MockPubSub_SubscribeServerMockRecorder {
	return m.recorder
}
func (m *MockPubSub_SubscribeServer) Send(arg0 *proto.SubscribeResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPubSub_SubscribeServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockPubSub_SubscribeServer)(nil).Send), arg0)
}
func (m *MockPubSub_SubscribeServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPubSub_SubscribeServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockPubSub_SubscribeServer)(nil).SetHeader), arg0)
}