// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/pb/gateway.pb.go

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

import (
	context "context"
	reflect "reflect"

	pb "github.com/camunda-community-hub/zeebe-client-go/v8/pkg/pb"
	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)

// MockisDeployment_Metadata is a mock of isDeployment_Metadata interface.
type MockisDeployment_Metadata struct {
	ctrl     *gomock.Controller
	recorder *MockisDeployment_MetadataMockRecorder
}

// MockisDeployment_MetadataMockRecorder is the mock recorder for MockisDeployment_Metadata.
type MockisDeployment_MetadataMockRecorder struct {
	mock *MockisDeployment_Metadata
}

// NewMockisDeployment_Metadata creates a new mock instance.
func NewMockisDeployment_Metadata(ctrl *gomock.Controller) *MockisDeployment_Metadata {
	mock := &MockisDeployment_Metadata{ctrl: ctrl}
	mock.recorder = &MockisDeployment_MetadataMockRecorder{mock}
	return mock
}

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

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

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

// MockGatewayClient is a mock of GatewayClient interface.
type MockGatewayClient struct {
	ctrl     *gomock.Controller
	recorder *MockGatewayClientMockRecorder
}

// MockGatewayClientMockRecorder is the mock recorder for MockGatewayClient.
type MockGatewayClientMockRecorder struct {
	mock *MockGatewayClient
}

// NewMockGatewayClient creates a new mock instance.
func NewMockGatewayClient(ctrl *gomock.Controller) *MockGatewayClient {
	mock := &MockGatewayClient{ctrl: ctrl}
	mock.recorder = &MockGatewayClientMockRecorder{mock}
	return mock
}

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

// ActivateJobs mocks base method.
func (m *MockGatewayClient) ActivateJobs(ctx context.Context, in *pb.ActivateJobsRequest, opts ...grpc.CallOption) (pb.Gateway_ActivateJobsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ActivateJobs", varargs...)
	ret0, _ := ret[0].(pb.Gateway_ActivateJobsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ActivateJobs indicates an expected call of ActivateJobs.
func (mr *MockGatewayClientMockRecorder) ActivateJobs(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, "ActivateJobs", reflect.TypeOf((*MockGatewayClient)(nil).ActivateJobs), varargs...)
}

// BroadcastSignal mocks base method.
func (m *MockGatewayClient) BroadcastSignal(ctx context.Context, in *pb.BroadcastSignalRequest, opts ...grpc.CallOption) (*pb.BroadcastSignalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BroadcastSignal", varargs...)
	ret0, _ := ret[0].(*pb.BroadcastSignalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BroadcastSignal indicates an expected call of BroadcastSignal.
func (mr *MockGatewayClientMockRecorder) BroadcastSignal(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, "BroadcastSignal", reflect.TypeOf((*MockGatewayClient)(nil).BroadcastSignal), varargs...)
}

// CancelProcessInstance mocks base method.
func (m *MockGatewayClient) CancelProcessInstance(ctx context.Context, in *pb.CancelProcessInstanceRequest, opts ...grpc.CallOption) (*pb.CancelProcessInstanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelProcessInstance", varargs...)
	ret0, _ := ret[0].(*pb.CancelProcessInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelProcessInstance indicates an expected call of CancelProcessInstance.
func (mr *MockGatewayClientMockRecorder) CancelProcessInstance(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, "CancelProcessInstance", reflect.TypeOf((*MockGatewayClient)(nil).CancelProcessInstance), varargs...)
}

// CompleteJob mocks base method.
func (m *MockGatewayClient) CompleteJob(ctx context.Context, in *pb.CompleteJobRequest, opts ...grpc.CallOption) (*pb.CompleteJobResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CompleteJob", varargs...)
	ret0, _ := ret[0].(*pb.CompleteJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteJob indicates an expected call of CompleteJob.
func (mr *MockGatewayClientMockRecorder) CompleteJob(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, "CompleteJob", reflect.TypeOf((*MockGatewayClient)(nil).CompleteJob), varargs...)
}

// CreateProcessInstance mocks base method.
func (m *MockGatewayClient) CreateProcessInstance(ctx context.Context, in *pb.CreateProcessInstanceRequest, opts ...grpc.CallOption) (*pb.CreateProcessInstanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateProcessInstance", varargs...)
	ret0, _ := ret[0].(*pb.CreateProcessInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateProcessInstance indicates an expected call of CreateProcessInstance.
func (mr *MockGatewayClientMockRecorder) CreateProcessInstance(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, "CreateProcessInstance", reflect.TypeOf((*MockGatewayClient)(nil).CreateProcessInstance), varargs...)
}

// CreateProcessInstanceWithResult mocks base method.
func (m *MockGatewayClient) CreateProcessInstanceWithResult(ctx context.Context, in *pb.CreateProcessInstanceWithResultRequest, opts ...grpc.CallOption) (*pb.CreateProcessInstanceWithResultResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateProcessInstanceWithResult", varargs...)
	ret0, _ := ret[0].(*pb.CreateProcessInstanceWithResultResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateProcessInstanceWithResult indicates an expected call of CreateProcessInstanceWithResult.
func (mr *MockGatewayClientMockRecorder) CreateProcessInstanceWithResult(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, "CreateProcessInstanceWithResult", reflect.TypeOf((*MockGatewayClient)(nil).CreateProcessInstanceWithResult), varargs...)
}

// DeleteResource mocks base method.
func (m *MockGatewayClient) DeleteResource(ctx context.Context, in *pb.DeleteResourceRequest, opts ...grpc.CallOption) (*pb.DeleteResourceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteResource", varargs...)
	ret0, _ := ret[0].(*pb.DeleteResourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteResource indicates an expected call of DeleteResource.
func (mr *MockGatewayClientMockRecorder) DeleteResource(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, "DeleteResource", reflect.TypeOf((*MockGatewayClient)(nil).DeleteResource), varargs...)
}

// DeployProcess mocks base method.
func (m *MockGatewayClient) DeployProcess(ctx context.Context, in *pb.DeployProcessRequest, opts ...grpc.CallOption) (*pb.DeployProcessResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeployProcess", varargs...)
	ret0, _ := ret[0].(*pb.DeployProcessResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeployProcess indicates an expected call of DeployProcess.
func (mr *MockGatewayClientMockRecorder) DeployProcess(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, "DeployProcess", reflect.TypeOf((*MockGatewayClient)(nil).DeployProcess), varargs...)
}

// DeployResource mocks base method.
func (m *MockGatewayClient) DeployResource(ctx context.Context, in *pb.DeployResourceRequest, opts ...grpc.CallOption) (*pb.DeployResourceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeployResource", varargs...)
	ret0, _ := ret[0].(*pb.DeployResourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeployResource indicates an expected call of DeployResource.
func (mr *MockGatewayClientMockRecorder) DeployResource(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, "DeployResource", reflect.TypeOf((*MockGatewayClient)(nil).DeployResource), varargs...)
}

// EvaluateDecision mocks base method.
func (m *MockGatewayClient) EvaluateDecision(ctx context.Context, in *pb.EvaluateDecisionRequest, opts ...grpc.CallOption) (*pb.EvaluateDecisionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EvaluateDecision", varargs...)
	ret0, _ := ret[0].(*pb.EvaluateDecisionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EvaluateDecision indicates an expected call of EvaluateDecision.
func (mr *MockGatewayClientMockRecorder) EvaluateDecision(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, "EvaluateDecision", reflect.TypeOf((*MockGatewayClient)(nil).EvaluateDecision), varargs...)
}

// FailJob mocks base method.
func (m *MockGatewayClient) FailJob(ctx context.Context, in *pb.FailJobRequest, opts ...grpc.CallOption) (*pb.FailJobResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FailJob", varargs...)
	ret0, _ := ret[0].(*pb.FailJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FailJob indicates an expected call of FailJob.
func (mr *MockGatewayClientMockRecorder) FailJob(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, "FailJob", reflect.TypeOf((*MockGatewayClient)(nil).FailJob), varargs...)
}

// MigrateProcessInstance mocks base method.
func (m *MockGatewayClient) MigrateProcessInstance(ctx context.Context, in *pb.MigrateProcessInstanceRequest, opts ...grpc.CallOption) (*pb.MigrateProcessInstanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MigrateProcessInstance", varargs...)
	ret0, _ := ret[0].(*pb.MigrateProcessInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MigrateProcessInstance indicates an expected call of MigrateProcessInstance.
func (mr *MockGatewayClientMockRecorder) MigrateProcessInstance(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, "MigrateProcessInstance", reflect.TypeOf((*MockGatewayClient)(nil).MigrateProcessInstance), varargs...)
}

// ModifyProcessInstance mocks base method.
func (m *MockGatewayClient) ModifyProcessInstance(ctx context.Context, in *pb.ModifyProcessInstanceRequest, opts ...grpc.CallOption) (*pb.ModifyProcessInstanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyProcessInstance", varargs...)
	ret0, _ := ret[0].(*pb.ModifyProcessInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyProcessInstance indicates an expected call of ModifyProcessInstance.
func (mr *MockGatewayClientMockRecorder) ModifyProcessInstance(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, "ModifyProcessInstance", reflect.TypeOf((*MockGatewayClient)(nil).ModifyProcessInstance), varargs...)
}

// PublishMessage mocks base method.
func (m *MockGatewayClient) PublishMessage(ctx context.Context, in *pb.PublishMessageRequest, opts ...grpc.CallOption) (*pb.PublishMessageResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PublishMessage", varargs...)
	ret0, _ := ret[0].(*pb.PublishMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PublishMessage indicates an expected call of PublishMessage.
func (mr *MockGatewayClientMockRecorder) PublishMessage(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, "PublishMessage", reflect.TypeOf((*MockGatewayClient)(nil).PublishMessage), varargs...)
}

// ResolveIncident mocks base method.
func (m *MockGatewayClient) ResolveIncident(ctx context.Context, in *pb.ResolveIncidentRequest, opts ...grpc.CallOption) (*pb.ResolveIncidentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResolveIncident", varargs...)
	ret0, _ := ret[0].(*pb.ResolveIncidentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveIncident indicates an expected call of ResolveIncident.
func (mr *MockGatewayClientMockRecorder) ResolveIncident(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, "ResolveIncident", reflect.TypeOf((*MockGatewayClient)(nil).ResolveIncident), varargs...)
}

// SetVariables mocks base method.
func (m *MockGatewayClient) SetVariables(ctx context.Context, in *pb.SetVariablesRequest, opts ...grpc.CallOption) (*pb.SetVariablesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetVariables", varargs...)
	ret0, _ := ret[0].(*pb.SetVariablesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetVariables indicates an expected call of SetVariables.
func (mr *MockGatewayClientMockRecorder) SetVariables(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, "SetVariables", reflect.TypeOf((*MockGatewayClient)(nil).SetVariables), varargs...)
}

// StreamActivatedJobs mocks base method.
func (m *MockGatewayClient) StreamActivatedJobs(ctx context.Context, in *pb.StreamActivatedJobsRequest, opts ...grpc.CallOption) (pb.Gateway_StreamActivatedJobsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StreamActivatedJobs", varargs...)
	ret0, _ := ret[0].(pb.Gateway_StreamActivatedJobsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StreamActivatedJobs indicates an expected call of StreamActivatedJobs.
func (mr *MockGatewayClientMockRecorder) StreamActivatedJobs(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, "StreamActivatedJobs", reflect.TypeOf((*MockGatewayClient)(nil).StreamActivatedJobs), varargs...)
}

// ThrowError mocks base method.
func (m *MockGatewayClient) ThrowError(ctx context.Context, in *pb.ThrowErrorRequest, opts ...grpc.CallOption) (*pb.ThrowErrorResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ThrowError", varargs...)
	ret0, _ := ret[0].(*pb.ThrowErrorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ThrowError indicates an expected call of ThrowError.
func (mr *MockGatewayClientMockRecorder) ThrowError(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, "ThrowError", reflect.TypeOf((*MockGatewayClient)(nil).ThrowError), varargs...)
}

// Topology mocks base method.
func (m *MockGatewayClient) Topology(ctx context.Context, in *pb.TopologyRequest, opts ...grpc.CallOption) (*pb.TopologyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Topology", varargs...)
	ret0, _ := ret[0].(*pb.TopologyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Topology indicates an expected call of Topology.
func (mr *MockGatewayClientMockRecorder) Topology(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, "Topology", reflect.TypeOf((*MockGatewayClient)(nil).Topology), varargs...)
}

// UpdateJobRetries mocks base method.
func (m *MockGatewayClient) UpdateJobRetries(ctx context.Context, in *pb.UpdateJobRetriesRequest, opts ...grpc.CallOption) (*pb.UpdateJobRetriesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateJobRetries", varargs...)
	ret0, _ := ret[0].(*pb.UpdateJobRetriesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateJobRetries indicates an expected call of UpdateJobRetries.
func (mr *MockGatewayClientMockRecorder) UpdateJobRetries(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, "UpdateJobRetries", reflect.TypeOf((*MockGatewayClient)(nil).UpdateJobRetries), varargs...)
}

// UpdateJobTimeout mocks base method.
func (m *MockGatewayClient) UpdateJobTimeout(ctx context.Context, in *pb.UpdateJobTimeoutRequest, opts ...grpc.CallOption) (*pb.UpdateJobTimeoutResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateJobTimeout", varargs...)
	ret0, _ := ret[0].(*pb.UpdateJobTimeoutResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateJobTimeout indicates an expected call of UpdateJobTimeout.
func (mr *MockGatewayClientMockRecorder) UpdateJobTimeout(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, "UpdateJobTimeout", reflect.TypeOf((*MockGatewayClient)(nil).UpdateJobTimeout), varargs...)
}

// MockGateway_ActivateJobsClient is a mock of Gateway_ActivateJobsClient interface.
type MockGateway_ActivateJobsClient struct {
	ctrl     *gomock.Controller
	recorder *MockGateway_ActivateJobsClientMockRecorder
}

// MockGateway_ActivateJobsClientMockRecorder is the mock recorder for MockGateway_ActivateJobsClient.
type MockGateway_ActivateJobsClientMockRecorder struct {
	mock *MockGateway_ActivateJobsClient
}

// NewMockGateway_ActivateJobsClient creates a new mock instance.
func NewMockGateway_ActivateJobsClient(ctrl *gomock.Controller) *MockGateway_ActivateJobsClient {
	mock := &MockGateway_ActivateJobsClient{ctrl: ctrl}
	mock.recorder = &MockGateway_ActivateJobsClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockGateway_ActivateJobsClient) 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
}

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

// Recv mocks base method.
func (m *MockGateway_ActivateJobsClient) Recv() (*pb.ActivateJobsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*pb.ActivateJobsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockGateway_ActivateJobsClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockGateway_ActivateJobsClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockGateway_ActivateJobsClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockGateway_ActivateJobsClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockGateway_ActivateJobsClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockGateway_ActivateJobsClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockGateway_ActivateJobsClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

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

// MockGateway_StreamActivatedJobsClient is a mock of Gateway_StreamActivatedJobsClient interface.
type MockGateway_StreamActivatedJobsClient struct {
	ctrl     *gomock.Controller
	recorder *MockGateway_StreamActivatedJobsClientMockRecorder
}

// MockGateway_StreamActivatedJobsClientMockRecorder is the mock recorder for MockGateway_StreamActivatedJobsClient.
type MockGateway_StreamActivatedJobsClientMockRecorder struct {
	mock *MockGateway_StreamActivatedJobsClient
}

// NewMockGateway_StreamActivatedJobsClient creates a new mock instance.
func NewMockGateway_StreamActivatedJobsClient(ctrl *gomock.Controller) *MockGateway_StreamActivatedJobsClient {
	mock := &MockGateway_StreamActivatedJobsClient{ctrl: ctrl}
	mock.recorder = &MockGateway_StreamActivatedJobsClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockGateway_StreamActivatedJobsClient) 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
}

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

// Recv mocks base method.
func (m *MockGateway_StreamActivatedJobsClient) Recv() (*pb.ActivatedJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*pb.ActivatedJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockGateway_StreamActivatedJobsClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockGateway_StreamActivatedJobsClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockGateway_StreamActivatedJobsClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockGateway_StreamActivatedJobsClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockGateway_StreamActivatedJobsClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockGateway_StreamActivatedJobsClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockGateway_StreamActivatedJobsClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

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

// MockGatewayServer is a mock of GatewayServer interface.
type MockGatewayServer struct {
	ctrl     *gomock.Controller
	recorder *MockGatewayServerMockRecorder
}

// MockGatewayServerMockRecorder is the mock recorder for MockGatewayServer.
type MockGatewayServerMockRecorder struct {
	mock *MockGatewayServer
}

// NewMockGatewayServer creates a new mock instance.
func NewMockGatewayServer(ctrl *gomock.Controller) *MockGatewayServer {
	mock := &MockGatewayServer{ctrl: ctrl}
	mock.recorder = &MockGatewayServerMockRecorder{mock}
	return mock
}

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

// ActivateJobs mocks base method.
func (m *MockGatewayServer) ActivateJobs(arg0 *pb.ActivateJobsRequest, arg1 pb.Gateway_ActivateJobsServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActivateJobs", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// BroadcastSignal mocks base method.
func (m *MockGatewayServer) BroadcastSignal(arg0 context.Context, arg1 *pb.BroadcastSignalRequest) (*pb.BroadcastSignalResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BroadcastSignal", arg0, arg1)
	ret0, _ := ret[0].(*pb.BroadcastSignalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelProcessInstance mocks base method.
func (m *MockGatewayServer) CancelProcessInstance(arg0 context.Context, arg1 *pb.CancelProcessInstanceRequest) (*pb.CancelProcessInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelProcessInstance", arg0, arg1)
	ret0, _ := ret[0].(*pb.CancelProcessInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CompleteJob mocks base method.
func (m *MockGatewayServer) CompleteJob(arg0 context.Context, arg1 *pb.CompleteJobRequest) (*pb.CompleteJobResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteJob", arg0, arg1)
	ret0, _ := ret[0].(*pb.CompleteJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateProcessInstance mocks base method.
func (m *MockGatewayServer) CreateProcessInstance(arg0 context.Context, arg1 *pb.CreateProcessInstanceRequest) (*pb.CreateProcessInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProcessInstance", arg0, arg1)
	ret0, _ := ret[0].(*pb.CreateProcessInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateProcessInstanceWithResult mocks base method.
func (m *MockGatewayServer) CreateProcessInstanceWithResult(arg0 context.Context, arg1 *pb.CreateProcessInstanceWithResultRequest) (*pb.CreateProcessInstanceWithResultResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProcessInstanceWithResult", arg0, arg1)
	ret0, _ := ret[0].(*pb.CreateProcessInstanceWithResultResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteResource mocks base method.
func (m *MockGatewayServer) DeleteResource(arg0 context.Context, arg1 *pb.DeleteResourceRequest) (*pb.DeleteResourceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteResource", arg0, arg1)
	ret0, _ := ret[0].(*pb.DeleteResourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeployProcess mocks base method.
func (m *MockGatewayServer) DeployProcess(arg0 context.Context, arg1 *pb.DeployProcessRequest) (*pb.DeployProcessResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeployProcess", arg0, arg1)
	ret0, _ := ret[0].(*pb.DeployProcessResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeployResource mocks base method.
func (m *MockGatewayServer) DeployResource(arg0 context.Context, arg1 *pb.DeployResourceRequest) (*pb.DeployResourceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeployResource", arg0, arg1)
	ret0, _ := ret[0].(*pb.DeployResourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EvaluateDecision mocks base method.
func (m *MockGatewayServer) EvaluateDecision(arg0 context.Context, arg1 *pb.EvaluateDecisionRequest) (*pb.EvaluateDecisionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EvaluateDecision", arg0, arg1)
	ret0, _ := ret[0].(*pb.EvaluateDecisionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FailJob mocks base method.
func (m *MockGatewayServer) FailJob(arg0 context.Context, arg1 *pb.FailJobRequest) (*pb.FailJobResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FailJob", arg0, arg1)
	ret0, _ := ret[0].(*pb.FailJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MigrateProcessInstance mocks base method.
func (m *MockGatewayServer) MigrateProcessInstance(arg0 context.Context, arg1 *pb.MigrateProcessInstanceRequest) (*pb.MigrateProcessInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MigrateProcessInstance", arg0, arg1)
	ret0, _ := ret[0].(*pb.MigrateProcessInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyProcessInstance mocks base method.
func (m *MockGatewayServer) ModifyProcessInstance(arg0 context.Context, arg1 *pb.ModifyProcessInstanceRequest) (*pb.ModifyProcessInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyProcessInstance", arg0, arg1)
	ret0, _ := ret[0].(*pb.ModifyProcessInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PublishMessage mocks base method.
func (m *MockGatewayServer) PublishMessage(arg0 context.Context, arg1 *pb.PublishMessageRequest) (*pb.PublishMessageResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishMessage", arg0, arg1)
	ret0, _ := ret[0].(*pb.PublishMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResolveIncident mocks base method.
func (m *MockGatewayServer) ResolveIncident(arg0 context.Context, arg1 *pb.ResolveIncidentRequest) (*pb.ResolveIncidentResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveIncident", arg0, arg1)
	ret0, _ := ret[0].(*pb.ResolveIncidentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetVariables mocks base method.
func (m *MockGatewayServer) SetVariables(arg0 context.Context, arg1 *pb.SetVariablesRequest) (*pb.SetVariablesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVariables", arg0, arg1)
	ret0, _ := ret[0].(*pb.SetVariablesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StreamActivatedJobs mocks base method.
func (m *MockGatewayServer) StreamActivatedJobs(arg0 *pb.StreamActivatedJobsRequest, arg1 pb.Gateway_StreamActivatedJobsServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamActivatedJobs", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ThrowError mocks base method.
func (m *MockGatewayServer) ThrowError(arg0 context.Context, arg1 *pb.ThrowErrorRequest) (*pb.ThrowErrorResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ThrowError", arg0, arg1)
	ret0, _ := ret[0].(*pb.ThrowErrorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Topology mocks base method.
func (m *MockGatewayServer) Topology(arg0 context.Context, arg1 *pb.TopologyRequest) (*pb.TopologyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Topology", arg0, arg1)
	ret0, _ := ret[0].(*pb.TopologyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateJobRetries mocks base method.
func (m *MockGatewayServer) UpdateJobRetries(arg0 context.Context, arg1 *pb.UpdateJobRetriesRequest) (*pb.UpdateJobRetriesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateJobRetries", arg0, arg1)
	ret0, _ := ret[0].(*pb.UpdateJobRetriesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateJobTimeout mocks base method.
func (m *MockGatewayServer) UpdateJobTimeout(arg0 context.Context, arg1 *pb.UpdateJobTimeoutRequest) (*pb.UpdateJobTimeoutResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateJobTimeout", arg0, arg1)
	ret0, _ := ret[0].(*pb.UpdateJobTimeoutResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockGateway_ActivateJobsServer is a mock of Gateway_ActivateJobsServer interface.
type MockGateway_ActivateJobsServer struct {
	ctrl     *gomock.Controller
	recorder *MockGateway_ActivateJobsServerMockRecorder
}

// MockGateway_ActivateJobsServerMockRecorder is the mock recorder for MockGateway_ActivateJobsServer.
type MockGateway_ActivateJobsServerMockRecorder struct {
	mock *MockGateway_ActivateJobsServer
}

// NewMockGateway_ActivateJobsServer creates a new mock instance.
func NewMockGateway_ActivateJobsServer(ctrl *gomock.Controller) *MockGateway_ActivateJobsServer {
	mock := &MockGateway_ActivateJobsServer{ctrl: ctrl}
	mock.recorder = &MockGateway_ActivateJobsServerMockRecorder{mock}
	return mock
}

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

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

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

// RecvMsg mocks base method.
func (m_2 *MockGateway_ActivateJobsServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockGateway_ActivateJobsServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockGateway_ActivateJobsServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockGateway_ActivateJobsServer) Send(arg0 *pb.ActivateJobsResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SendHeader mocks base method.
func (m *MockGateway_ActivateJobsServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SendMsg mocks base method.
func (m_2 *MockGateway_ActivateJobsServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockGateway_ActivateJobsServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockGateway_ActivateJobsServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockGateway_ActivateJobsServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SetTrailer mocks base method.
func (m *MockGateway_ActivateJobsServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

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

// MockGateway_StreamActivatedJobsServer is a mock of Gateway_StreamActivatedJobsServer interface.
type MockGateway_StreamActivatedJobsServer struct {
	ctrl     *gomock.Controller
	recorder *MockGateway_StreamActivatedJobsServerMockRecorder
}

// MockGateway_StreamActivatedJobsServerMockRecorder is the mock recorder for MockGateway_StreamActivatedJobsServer.
type MockGateway_StreamActivatedJobsServerMockRecorder struct {
	mock *MockGateway_StreamActivatedJobsServer
}

// NewMockGateway_StreamActivatedJobsServer creates a new mock instance.
func NewMockGateway_StreamActivatedJobsServer(ctrl *gomock.Controller) *MockGateway_StreamActivatedJobsServer {
	mock := &MockGateway_StreamActivatedJobsServer{ctrl: ctrl}
	mock.recorder = &MockGateway_StreamActivatedJobsServerMockRecorder{mock}
	return mock
}

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

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

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

// RecvMsg mocks base method.
func (m_2 *MockGateway_StreamActivatedJobsServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockGateway_StreamActivatedJobsServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockGateway_StreamActivatedJobsServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockGateway_StreamActivatedJobsServer) Send(arg0 *pb.ActivatedJob) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SendHeader mocks base method.
func (m *MockGateway_StreamActivatedJobsServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SendMsg mocks base method.
func (m_2 *MockGateway_StreamActivatedJobsServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockGateway_StreamActivatedJobsServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockGateway_StreamActivatedJobsServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockGateway_StreamActivatedJobsServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SetTrailer mocks base method.
func (m *MockGateway_StreamActivatedJobsServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

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