// Code generated by MockGen. DO NOT EDIT.
// Source: nextgenglobal.go
//
// Generated by this command:
//
//	mockgen -source=nextgenglobal.go -package=mock_nextgenglobal -destination=./mock_nextgenglobal/mock_nextgenglobal.go
//

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

import (
	context "context"
	reflect "reflect"

	commonv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/common/v1"
	nextgenv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/nextgen/v1"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockNextGenGlobal is a mock of NextGenGlobal interface.
type MockNextGenGlobal struct {
	ctrl     *gomock.Controller
	recorder *MockNextGenGlobalMockRecorder
	isgomock struct{}
}

// MockNextGenGlobalMockRecorder is the mock recorder for MockNextGenGlobal.
type MockNextGenGlobalMockRecorder struct {
	mock *MockNextGenGlobal
}

// NewMockNextGenGlobal creates a new mock instance.
func NewMockNextGenGlobal(ctrl *gomock.Controller) *MockNextGenGlobal {
	mock := &MockNextGenGlobal{ctrl: ctrl}
	mock.recorder = &MockNextGenGlobalMockRecorder{mock}
	return mock
}

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

// BatchUpdateBackupSettingNames mocks base method.
func (m *MockNextGenGlobal) BatchUpdateBackupSettingNames(ctx context.Context, in *nextgenv1.BatchUpdateBackupSettingNamesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchUpdateBackupSettingNames", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchUpdateBackupSettingNames indicates an expected call of BatchUpdateBackupSettingNames.
func (mr *MockNextGenGlobalMockRecorder) BatchUpdateBackupSettingNames(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdateBackupSettingNames", reflect.TypeOf((*MockNextGenGlobal)(nil).BatchUpdateBackupSettingNames), varargs...)
}

// BeginPauseResourcePoolAdmission mocks base method.
func (m *MockNextGenGlobal) BeginPauseResourcePoolAdmission(ctx context.Context, in *nextgenv1.BeginPauseResourcePoolAdmissionRequest, opts ...grpc.CallOption) (*nextgenv1.BeginPauseResourcePoolAdmissionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BeginPauseResourcePoolAdmission", varargs...)
	ret0, _ := ret[0].(*nextgenv1.BeginPauseResourcePoolAdmissionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeginPauseResourcePoolAdmission indicates an expected call of BeginPauseResourcePoolAdmission.
func (mr *MockNextGenGlobalMockRecorder) BeginPauseResourcePoolAdmission(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginPauseResourcePoolAdmission", reflect.TypeOf((*MockNextGenGlobal)(nil).BeginPauseResourcePoolAdmission), varargs...)
}

// CalculateMinRcu mocks base method.
func (m *MockNextGenGlobal) CalculateMinRcu(ctx context.Context, in *nextgenv1.CalculateMinRcuRequest, opts ...grpc.CallOption) (*nextgenv1.CalculateMinRcuResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CalculateMinRcu", varargs...)
	ret0, _ := ret[0].(*nextgenv1.CalculateMinRcuResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalculateMinRcu indicates an expected call of CalculateMinRcu.
func (mr *MockNextGenGlobalMockRecorder) CalculateMinRcu(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalculateMinRcu", reflect.TypeOf((*MockNextGenGlobal)(nil).CalculateMinRcu), varargs...)
}

// CancelExport mocks base method.
func (m *MockNextGenGlobal) CancelExport(ctx context.Context, in *nextgenv1.CancelExportRequest, opts ...grpc.CallOption) (*nextgenv1.Export, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelExport", varargs...)
	ret0, _ := ret[0].(*nextgenv1.Export)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelExport indicates an expected call of CancelExport.
func (mr *MockNextGenGlobalMockRecorder) CancelExport(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExport", reflect.TypeOf((*MockNextGenGlobal)(nil).CancelExport), varargs...)
}

// ChangeClusterPasswd mocks base method.
func (m *MockNextGenGlobal) ChangeClusterPasswd(ctx context.Context, in *nextgenv1.ChangeClusterPasswdRequest, opts ...grpc.CallOption) (*nextgenv1.ChangeClusterPasswdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeClusterPasswd", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ChangeClusterPasswdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeClusterPasswd indicates an expected call of ChangeClusterPasswd.
func (mr *MockNextGenGlobalMockRecorder) ChangeClusterPasswd(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeClusterPasswd", reflect.TypeOf((*MockNextGenGlobal)(nil).ChangeClusterPasswd), varargs...)
}

// CreateAuditLogFilterRule mocks base method.
func (m *MockNextGenGlobal) CreateAuditLogFilterRule(ctx context.Context, in *nextgenv1.CreateAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*nextgenv1.AuditLogFilterRule, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAuditLogFilterRule", varargs...)
	ret0, _ := ret[0].(*nextgenv1.AuditLogFilterRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAuditLogFilterRule indicates an expected call of CreateAuditLogFilterRule.
func (mr *MockNextGenGlobalMockRecorder) CreateAuditLogFilterRule(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAuditLogFilterRule", reflect.TypeOf((*MockNextGenGlobal)(nil).CreateAuditLogFilterRule), varargs...)
}

// CreateCluster mocks base method.
func (m *MockNextGenGlobal) CreateCluster(ctx context.Context, in *nextgenv1.CreateClusterRequest, opts ...grpc.CallOption) (*nextgenv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCluster", varargs...)
	ret0, _ := ret[0].(*nextgenv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCluster indicates an expected call of CreateCluster.
func (mr *MockNextGenGlobalMockRecorder) CreateCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockNextGenGlobal)(nil).CreateCluster), varargs...)
}

// CreateExport mocks base method.
func (m *MockNextGenGlobal) CreateExport(ctx context.Context, in *nextgenv1.CreateExportRequest, opts ...grpc.CallOption) (*nextgenv1.Export, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateExport", varargs...)
	ret0, _ := ret[0].(*nextgenv1.Export)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateExport indicates an expected call of CreateExport.
func (mr *MockNextGenGlobalMockRecorder) CreateExport(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExport", reflect.TypeOf((*MockNextGenGlobal)(nil).CreateExport), varargs...)
}

// CreateFinalBackup mocks base method.
func (m *MockNextGenGlobal) CreateFinalBackup(ctx context.Context, in *nextgenv1.CreateFinalBackupRequest, opts ...grpc.CallOption) (*nextgenv1.CreateFinalBackupResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFinalBackup", varargs...)
	ret0, _ := ret[0].(*nextgenv1.CreateFinalBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFinalBackup indicates an expected call of CreateFinalBackup.
func (mr *MockNextGenGlobalMockRecorder) CreateFinalBackup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFinalBackup", reflect.TypeOf((*MockNextGenGlobal)(nil).CreateFinalBackup), varargs...)
}

// CreateManualBackup mocks base method.
func (m *MockNextGenGlobal) CreateManualBackup(ctx context.Context, in *nextgenv1.CreateManualBackupRequest, opts ...grpc.CallOption) (*nextgenv1.CreateManualBackupResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateManualBackup", varargs...)
	ret0, _ := ret[0].(*nextgenv1.CreateManualBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateManualBackup indicates an expected call of CreateManualBackup.
func (mr *MockNextGenGlobalMockRecorder) CreateManualBackup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManualBackup", reflect.TypeOf((*MockNextGenGlobal)(nil).CreateManualBackup), varargs...)
}

// CreatePrivateLinkConnection mocks base method.
func (m *MockNextGenGlobal) CreatePrivateLinkConnection(ctx context.Context, in *nextgenv1.CreatePrivateLinkConnectionRequest, opts ...grpc.CallOption) (*nextgenv1.PrivateLinkConnection, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePrivateLinkConnection", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PrivateLinkConnection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePrivateLinkConnection indicates an expected call of CreatePrivateLinkConnection.
func (mr *MockNextGenGlobalMockRecorder) CreatePrivateLinkConnection(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePrivateLinkConnection", reflect.TypeOf((*MockNextGenGlobal)(nil).CreatePrivateLinkConnection), varargs...)
}

// CreatePrivateLinkService mocks base method.
func (m *MockNextGenGlobal) CreatePrivateLinkService(ctx context.Context, in *nextgenv1.CreatePrivateLinkServiceRequest, opts ...grpc.CallOption) (*nextgenv1.PrivateLinkService, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePrivateLinkService", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PrivateLinkService)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePrivateLinkService indicates an expected call of CreatePrivateLinkService.
func (mr *MockNextGenGlobalMockRecorder) CreatePrivateLinkService(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePrivateLinkService", reflect.TypeOf((*MockNextGenGlobal)(nil).CreatePrivateLinkService), varargs...)
}

// CreateReservedCapacityTemplate mocks base method.
func (m *MockNextGenGlobal) CreateReservedCapacityTemplate(ctx context.Context, in *nextgenv1.CreateReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*nextgenv1.ReservedCapacityTemplate, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateReservedCapacityTemplate", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ReservedCapacityTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReservedCapacityTemplate indicates an expected call of CreateReservedCapacityTemplate.
func (mr *MockNextGenGlobalMockRecorder) CreateReservedCapacityTemplate(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedCapacityTemplate", reflect.TypeOf((*MockNextGenGlobal)(nil).CreateReservedCapacityTemplate), varargs...)
}

// CreateResourcePool mocks base method.
func (m *MockNextGenGlobal) CreateResourcePool(ctx context.Context, in *nextgenv1.CreateResourcePoolRequest, opts ...grpc.CallOption) (*nextgenv1.ResourcePoolProfile, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateResourcePool", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResourcePoolProfile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateResourcePool indicates an expected call of CreateResourcePool.
func (mr *MockNextGenGlobalMockRecorder) CreateResourcePool(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourcePool", reflect.TypeOf((*MockNextGenGlobal)(nil).CreateResourcePool), varargs...)
}

// DeleteAuditLogFilterRule mocks base method.
func (m *MockNextGenGlobal) DeleteAuditLogFilterRule(ctx context.Context, in *nextgenv1.DeleteAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAuditLogFilterRule", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAuditLogFilterRule indicates an expected call of DeleteAuditLogFilterRule.
func (mr *MockNextGenGlobalMockRecorder) DeleteAuditLogFilterRule(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAuditLogFilterRule", reflect.TypeOf((*MockNextGenGlobal)(nil).DeleteAuditLogFilterRule), varargs...)
}

// DeleteBackup mocks base method.
func (m *MockNextGenGlobal) DeleteBackup(ctx context.Context, in *nextgenv1.DeleteBackupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBackup", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBackup indicates an expected call of DeleteBackup.
func (mr *MockNextGenGlobalMockRecorder) DeleteBackup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBackup", reflect.TypeOf((*MockNextGenGlobal)(nil).DeleteBackup), varargs...)
}

// DeleteCluster mocks base method.
func (m *MockNextGenGlobal) DeleteCluster(ctx context.Context, in *nextgenv1.DeleteClusterRequest, opts ...grpc.CallOption) (*nextgenv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCluster", varargs...)
	ret0, _ := ret[0].(*nextgenv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCluster indicates an expected call of DeleteCluster.
func (mr *MockNextGenGlobalMockRecorder) DeleteCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCluster", reflect.TypeOf((*MockNextGenGlobal)(nil).DeleteCluster), varargs...)
}

// DeleteClusterBackup mocks base method.
func (m *MockNextGenGlobal) DeleteClusterBackup(ctx context.Context, in *nextgenv1.DeleteClusterBackupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteClusterBackup", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteClusterBackup indicates an expected call of DeleteClusterBackup.
func (mr *MockNextGenGlobalMockRecorder) DeleteClusterBackup(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterBackup", reflect.TypeOf((*MockNextGenGlobal)(nil).DeleteClusterBackup), varargs...)
}

// DeleteExport mocks base method.
func (m *MockNextGenGlobal) DeleteExport(ctx context.Context, in *nextgenv1.DeleteExportRequest, opts ...grpc.CallOption) (*nextgenv1.Export, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteExport", varargs...)
	ret0, _ := ret[0].(*nextgenv1.Export)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteExport indicates an expected call of DeleteExport.
func (mr *MockNextGenGlobalMockRecorder) DeleteExport(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExport", reflect.TypeOf((*MockNextGenGlobal)(nil).DeleteExport), varargs...)
}

// DeletePrivateLinkConnection mocks base method.
func (m *MockNextGenGlobal) DeletePrivateLinkConnection(ctx context.Context, in *nextgenv1.DeletePrivateLinkConnectionRequest, opts ...grpc.CallOption) (*nextgenv1.PrivateLinkConnection, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePrivateLinkConnection", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PrivateLinkConnection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePrivateLinkConnection indicates an expected call of DeletePrivateLinkConnection.
func (mr *MockNextGenGlobalMockRecorder) DeletePrivateLinkConnection(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePrivateLinkConnection", reflect.TypeOf((*MockNextGenGlobal)(nil).DeletePrivateLinkConnection), varargs...)
}

// DeletePrivateLinkService mocks base method.
func (m *MockNextGenGlobal) DeletePrivateLinkService(ctx context.Context, in *nextgenv1.DeletePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePrivateLinkService", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePrivateLinkService indicates an expected call of DeletePrivateLinkService.
func (mr *MockNextGenGlobalMockRecorder) DeletePrivateLinkService(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePrivateLinkService", reflect.TypeOf((*MockNextGenGlobal)(nil).DeletePrivateLinkService), varargs...)
}

// DeleteRegion mocks base method.
func (m *MockNextGenGlobal) DeleteRegion(ctx context.Context, in *nextgenv1.DeleteRegionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRegion", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRegion indicates an expected call of DeleteRegion.
func (mr *MockNextGenGlobalMockRecorder) DeleteRegion(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegion", reflect.TypeOf((*MockNextGenGlobal)(nil).DeleteRegion), varargs...)
}

// DeleteReservedCapacityTemplate mocks base method.
func (m *MockNextGenGlobal) DeleteReservedCapacityTemplate(ctx context.Context, in *nextgenv1.DeleteReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteReservedCapacityTemplate", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteReservedCapacityTemplate indicates an expected call of DeleteReservedCapacityTemplate.
func (mr *MockNextGenGlobalMockRecorder) DeleteReservedCapacityTemplate(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReservedCapacityTemplate", reflect.TypeOf((*MockNextGenGlobal)(nil).DeleteReservedCapacityTemplate), varargs...)
}

// DeleteResourcePool mocks base method.
func (m *MockNextGenGlobal) DeleteResourcePool(ctx context.Context, in *nextgenv1.DeleteResourcePoolRequest, opts ...grpc.CallOption) (*nextgenv1.ResourcePool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteResourcePool", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResourcePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteResourcePool indicates an expected call of DeleteResourcePool.
func (mr *MockNextGenGlobalMockRecorder) DeleteResourcePool(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePool", reflect.TypeOf((*MockNextGenGlobal)(nil).DeleteResourcePool), varargs...)
}

// EstimatePrice mocks base method.
func (m *MockNextGenGlobal) EstimatePrice(ctx context.Context, in *nextgenv1.EstimatePriceRequest, opts ...grpc.CallOption) (*nextgenv1.EstimatePriceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EstimatePrice", varargs...)
	ret0, _ := ret[0].(*nextgenv1.EstimatePriceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EstimatePrice indicates an expected call of EstimatePrice.
func (mr *MockNextGenGlobalMockRecorder) EstimatePrice(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimatePrice", reflect.TypeOf((*MockNextGenGlobal)(nil).EstimatePrice), varargs...)
}

// ForceUpdateGatewayIdentity mocks base method.
func (m *MockNextGenGlobal) ForceUpdateGatewayIdentity(ctx context.Context, in *nextgenv1.ForceUpdateGatewayIdentityRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ForceUpdateGatewayIdentity", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForceUpdateGatewayIdentity indicates an expected call of ForceUpdateGatewayIdentity.
func (mr *MockNextGenGlobalMockRecorder) ForceUpdateGatewayIdentity(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceUpdateGatewayIdentity", reflect.TypeOf((*MockNextGenGlobal)(nil).ForceUpdateGatewayIdentity), varargs...)
}

// GetAuditLogSetting mocks base method.
func (m *MockNextGenGlobal) GetAuditLogSetting(ctx context.Context, in *nextgenv1.GetAuditLogSettingRequest, opts ...grpc.CallOption) (*nextgenv1.AuditLogSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAuditLogSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.AuditLogSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuditLogSetting indicates an expected call of GetAuditLogSetting.
func (mr *MockNextGenGlobalMockRecorder) GetAuditLogSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuditLogSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).GetAuditLogSetting), varargs...)
}

// GetBackupSetting mocks base method.
func (m *MockNextGenGlobal) GetBackupSetting(ctx context.Context, in *nextgenv1.GetBackupSettingRequest, opts ...grpc.CallOption) (*nextgenv1.BackupSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBackupSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.BackupSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBackupSetting indicates an expected call of GetBackupSetting.
func (mr *MockNextGenGlobalMockRecorder) GetBackupSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBackupSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).GetBackupSetting), varargs...)
}

// GetByocSharedComponentScaleConstraints mocks base method.
func (m *MockNextGenGlobal) GetByocSharedComponentScaleConstraints(ctx context.Context, in *nextgenv1.GetByocSharedComponentScaleConstraintsRequest, opts ...grpc.CallOption) (*nextgenv1.ByocSharedComponentScaleConstraints, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetByocSharedComponentScaleConstraints", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ByocSharedComponentScaleConstraints)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByocSharedComponentScaleConstraints indicates an expected call of GetByocSharedComponentScaleConstraints.
func (mr *MockNextGenGlobalMockRecorder) GetByocSharedComponentScaleConstraints(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByocSharedComponentScaleConstraints", reflect.TypeOf((*MockNextGenGlobal)(nil).GetByocSharedComponentScaleConstraints), varargs...)
}

// GetCaCertificateDownloadUrl mocks base method.
func (m *MockNextGenGlobal) GetCaCertificateDownloadUrl(ctx context.Context, in *nextgenv1.GetCaCertificateDownloadUrlRequest, opts ...grpc.CallOption) (*nextgenv1.CaCertificateDownloadUrl, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCaCertificateDownloadUrl", varargs...)
	ret0, _ := ret[0].(*nextgenv1.CaCertificateDownloadUrl)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCaCertificateDownloadUrl indicates an expected call of GetCaCertificateDownloadUrl.
func (mr *MockNextGenGlobalMockRecorder) GetCaCertificateDownloadUrl(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCaCertificateDownloadUrl", reflect.TypeOf((*MockNextGenGlobal)(nil).GetCaCertificateDownloadUrl), varargs...)
}

// GetCluster mocks base method.
func (m *MockNextGenGlobal) GetCluster(ctx context.Context, in *nextgenv1.GetClusterRequest, opts ...grpc.CallOption) (*nextgenv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCluster", varargs...)
	ret0, _ := ret[0].(*nextgenv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCluster indicates an expected call of GetCluster.
func (mr *MockNextGenGlobalMockRecorder) GetCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockNextGenGlobal)(nil).GetCluster), varargs...)
}

// GetClusterEncryptionStatus mocks base method.
func (m *MockNextGenGlobal) GetClusterEncryptionStatus(ctx context.Context, in *nextgenv1.GetClusterEncryptionStatusRequest, opts ...grpc.CallOption) (*nextgenv1.ClusterEncryptionStatus, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterEncryptionStatus", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ClusterEncryptionStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterEncryptionStatus indicates an expected call of GetClusterEncryptionStatus.
func (mr *MockNextGenGlobalMockRecorder) GetClusterEncryptionStatus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterEncryptionStatus", reflect.TypeOf((*MockNextGenGlobal)(nil).GetClusterEncryptionStatus), varargs...)
}

// GetCmekAccessIamPrincipal mocks base method.
func (m *MockNextGenGlobal) GetCmekAccessIamPrincipal(ctx context.Context, in *nextgenv1.GetCmekAccessIamPrincipalRequest, opts ...grpc.CallOption) (*nextgenv1.CmekAccessIamPrincipal, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCmekAccessIamPrincipal", varargs...)
	ret0, _ := ret[0].(*nextgenv1.CmekAccessIamPrincipal)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCmekAccessIamPrincipal indicates an expected call of GetCmekAccessIamPrincipal.
func (mr *MockNextGenGlobalMockRecorder) GetCmekAccessIamPrincipal(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCmekAccessIamPrincipal", reflect.TypeOf((*MockNextGenGlobal)(nil).GetCmekAccessIamPrincipal), varargs...)
}

// GetCustomerManagedEncryptionKey mocks base method.
func (m *MockNextGenGlobal) GetCustomerManagedEncryptionKey(ctx context.Context, in *nextgenv1.GetCustomerManagedEncryptionKeyRequest, opts ...grpc.CallOption) (*nextgenv1.CustomerManagedEncryptionKey, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCustomerManagedEncryptionKey", varargs...)
	ret0, _ := ret[0].(*nextgenv1.CustomerManagedEncryptionKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCustomerManagedEncryptionKey indicates an expected call of GetCustomerManagedEncryptionKey.
func (mr *MockNextGenGlobalMockRecorder) GetCustomerManagedEncryptionKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomerManagedEncryptionKey", reflect.TypeOf((*MockNextGenGlobal)(nil).GetCustomerManagedEncryptionKey), varargs...)
}

// GetCustomerManagedEncryptionKeyByClusterId mocks base method.
func (m *MockNextGenGlobal) GetCustomerManagedEncryptionKeyByClusterId(ctx context.Context, in *nextgenv1.GetCustomerManagedEncryptionKeyByClusterIdRequest, opts ...grpc.CallOption) (*nextgenv1.CustomerManagedEncryptionKey, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCustomerManagedEncryptionKeyByClusterId", varargs...)
	ret0, _ := ret[0].(*nextgenv1.CustomerManagedEncryptionKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCustomerManagedEncryptionKeyByClusterId indicates an expected call of GetCustomerManagedEncryptionKeyByClusterId.
func (mr *MockNextGenGlobalMockRecorder) GetCustomerManagedEncryptionKeyByClusterId(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomerManagedEncryptionKeyByClusterId", reflect.TypeOf((*MockNextGenGlobal)(nil).GetCustomerManagedEncryptionKeyByClusterId), varargs...)
}

// GetExport mocks base method.
func (m *MockNextGenGlobal) GetExport(ctx context.Context, in *nextgenv1.GetExportRequest, opts ...grpc.CallOption) (*nextgenv1.Export, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetExport", varargs...)
	ret0, _ := ret[0].(*nextgenv1.Export)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExport indicates an expected call of GetExport.
func (mr *MockNextGenGlobalMockRecorder) GetExport(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExport", reflect.TypeOf((*MockNextGenGlobal)(nil).GetExport), varargs...)
}

// GetLogRedactionPolicy mocks base method.
func (m *MockNextGenGlobal) GetLogRedactionPolicy(ctx context.Context, in *nextgenv1.GetLogRedactionPolicyRequest, opts ...grpc.CallOption) (*nextgenv1.LogRedactionPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLogRedactionPolicy", varargs...)
	ret0, _ := ret[0].(*nextgenv1.LogRedactionPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogRedactionPolicy indicates an expected call of GetLogRedactionPolicy.
func (mr *MockNextGenGlobalMockRecorder) GetLogRedactionPolicy(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogRedactionPolicy", reflect.TypeOf((*MockNextGenGlobal)(nil).GetLogRedactionPolicy), varargs...)
}

// GetPlanReplayerStatus mocks base method.
func (m *MockNextGenGlobal) GetPlanReplayerStatus(ctx context.Context, in *nextgenv1.GetPlanReplayerStatusRequest, opts ...grpc.CallOption) (*nextgenv1.PlanReplayerStatus, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPlanReplayerStatus", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PlanReplayerStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPlanReplayerStatus indicates an expected call of GetPlanReplayerStatus.
func (mr *MockNextGenGlobalMockRecorder) GetPlanReplayerStatus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlanReplayerStatus", reflect.TypeOf((*MockNextGenGlobal)(nil).GetPlanReplayerStatus), varargs...)
}

// GetPrivateLinkConnection mocks base method.
func (m *MockNextGenGlobal) GetPrivateLinkConnection(ctx context.Context, in *nextgenv1.GetPrivateLinkConnectionRequest, opts ...grpc.CallOption) (*nextgenv1.PrivateLinkConnection, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPrivateLinkConnection", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PrivateLinkConnection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrivateLinkConnection indicates an expected call of GetPrivateLinkConnection.
func (mr *MockNextGenGlobalMockRecorder) GetPrivateLinkConnection(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateLinkConnection", reflect.TypeOf((*MockNextGenGlobal)(nil).GetPrivateLinkConnection), varargs...)
}

// GetProviderRole mocks base method.
func (m *MockNextGenGlobal) GetProviderRole(ctx context.Context, in *nextgenv1.GetProviderRoleRequest, opts ...grpc.CallOption) (*nextgenv1.ProviderRole, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProviderRole", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ProviderRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProviderRole indicates an expected call of GetProviderRole.
func (mr *MockNextGenGlobalMockRecorder) GetProviderRole(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProviderRole", reflect.TypeOf((*MockNextGenGlobal)(nil).GetProviderRole), varargs...)
}

// GetPublicConnectionSetting mocks base method.
func (m *MockNextGenGlobal) GetPublicConnectionSetting(ctx context.Context, in *nextgenv1.GetPublicConnectionSettingRequest, opts ...grpc.CallOption) (*nextgenv1.PublicConnectionSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPublicConnectionSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PublicConnectionSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPublicConnectionSetting indicates an expected call of GetPublicConnectionSetting.
func (mr *MockNextGenGlobalMockRecorder) GetPublicConnectionSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicConnectionSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).GetPublicConnectionSetting), varargs...)
}

// GetRcuQuota mocks base method.
func (m *MockNextGenGlobal) GetRcuQuota(ctx context.Context, in *nextgenv1.GetRcuQuotaRequest, opts ...grpc.CallOption) (*nextgenv1.RcuQuota, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRcuQuota", varargs...)
	ret0, _ := ret[0].(*nextgenv1.RcuQuota)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRcuQuota indicates an expected call of GetRcuQuota.
func (mr *MockNextGenGlobalMockRecorder) GetRcuQuota(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRcuQuota", reflect.TypeOf((*MockNextGenGlobal)(nil).GetRcuQuota), varargs...)
}

// GetRegionByClusterId mocks base method.
func (m *MockNextGenGlobal) GetRegionByClusterId(ctx context.Context, in *nextgenv1.GetRegionByClusterIdRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRegionByClusterId", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRegionByClusterId indicates an expected call of GetRegionByClusterId.
func (mr *MockNextGenGlobalMockRecorder) GetRegionByClusterId(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionByClusterId", reflect.TypeOf((*MockNextGenGlobal)(nil).GetRegionByClusterId), varargs...)
}

// GetRegionByLogicalName mocks base method.
func (m *MockNextGenGlobal) GetRegionByLogicalName(ctx context.Context, in *nextgenv1.GetRegionByLogicalNameRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRegionByLogicalName", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRegionByLogicalName indicates an expected call of GetRegionByLogicalName.
func (mr *MockNextGenGlobalMockRecorder) GetRegionByLogicalName(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegionByLogicalName", reflect.TypeOf((*MockNextGenGlobal)(nil).GetRegionByLogicalName), varargs...)
}

// GetReservedCapacityTemplate mocks base method.
func (m *MockNextGenGlobal) GetReservedCapacityTemplate(ctx context.Context, in *nextgenv1.GetReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*nextgenv1.ReservedCapacityTemplate, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetReservedCapacityTemplate", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ReservedCapacityTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReservedCapacityTemplate indicates an expected call of GetReservedCapacityTemplate.
func (mr *MockNextGenGlobalMockRecorder) GetReservedCapacityTemplate(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedCapacityTemplate", reflect.TypeOf((*MockNextGenGlobal)(nil).GetReservedCapacityTemplate), varargs...)
}

// GetResourcePool mocks base method.
func (m *MockNextGenGlobal) GetResourcePool(ctx context.Context, in *nextgenv1.GetResourcePoolRequest, opts ...grpc.CallOption) (*nextgenv1.ResourcePoolProfile, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetResourcePool", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResourcePoolProfile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourcePool indicates an expected call of GetResourcePool.
func (mr *MockNextGenGlobalMockRecorder) GetResourcePool(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePool", reflect.TypeOf((*MockNextGenGlobal)(nil).GetResourcePool), varargs...)
}

// GetResourcePoolCapacityConstraints mocks base method.
func (m *MockNextGenGlobal) GetResourcePoolCapacityConstraints(ctx context.Context, in *nextgenv1.GetResourcePoolCapacityConstraintsRequest, opts ...grpc.CallOption) (*nextgenv1.ResourcePoolCapacityConstraints, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetResourcePoolCapacityConstraints", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResourcePoolCapacityConstraints)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourcePoolCapacityConstraints indicates an expected call of GetResourcePoolCapacityConstraints.
func (mr *MockNextGenGlobalMockRecorder) GetResourcePoolCapacityConstraints(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePoolCapacityConstraints", reflect.TypeOf((*MockNextGenGlobal)(nil).GetResourcePoolCapacityConstraints), varargs...)
}

// GetResourcePoolPauseResumeOperation mocks base method.
func (m *MockNextGenGlobal) GetResourcePoolPauseResumeOperation(ctx context.Context, in *nextgenv1.GetResourcePoolPauseResumeOperationRequest, opts ...grpc.CallOption) (*nextgenv1.ResourcePoolPauseResumeOperation, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetResourcePoolPauseResumeOperation", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResourcePoolPauseResumeOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourcePoolPauseResumeOperation indicates an expected call of GetResourcePoolPauseResumeOperation.
func (mr *MockNextGenGlobalMockRecorder) GetResourcePoolPauseResumeOperation(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePoolPauseResumeOperation", reflect.TypeOf((*MockNextGenGlobal)(nil).GetResourcePoolPauseResumeOperation), varargs...)
}

// GetVpcPeering mocks base method.
func (m *MockNextGenGlobal) GetVpcPeering(ctx context.Context, in *nextgenv1.GetVpcPeeringRequest, opts ...grpc.CallOption) (*nextgenv1.VpcPeering, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVpcPeering", varargs...)
	ret0, _ := ret[0].(*nextgenv1.VpcPeering)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVpcPeering indicates an expected call of GetVpcPeering.
func (mr *MockNextGenGlobalMockRecorder) GetVpcPeering(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpcPeering", reflect.TypeOf((*MockNextGenGlobal)(nil).GetVpcPeering), varargs...)
}

// GetVpcPeeringAllowlistSetting mocks base method.
func (m *MockNextGenGlobal) GetVpcPeeringAllowlistSetting(ctx context.Context, in *nextgenv1.GetVpcPeeringAllowlistSettingRequest, opts ...grpc.CallOption) (*nextgenv1.VpcPeeringAllowlistSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVpcPeeringAllowlistSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.VpcPeeringAllowlistSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVpcPeeringAllowlistSetting indicates an expected call of GetVpcPeeringAllowlistSetting.
func (mr *MockNextGenGlobalMockRecorder) GetVpcPeeringAllowlistSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpcPeeringAllowlistSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).GetVpcPeeringAllowlistSetting), varargs...)
}

// ListAuditLogFilterRules mocks base method.
func (m *MockNextGenGlobal) ListAuditLogFilterRules(ctx context.Context, in *nextgenv1.ListAuditLogFilterRulesRequest, opts ...grpc.CallOption) (*nextgenv1.ListAuditLogFilterRulesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAuditLogFilterRules", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListAuditLogFilterRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAuditLogFilterRules indicates an expected call of ListAuditLogFilterRules.
func (mr *MockNextGenGlobalMockRecorder) ListAuditLogFilterRules(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAuditLogFilterRules", reflect.TypeOf((*MockNextGenGlobal)(nil).ListAuditLogFilterRules), varargs...)
}

// ListBackupPolicies mocks base method.
func (m *MockNextGenGlobal) ListBackupPolicies(ctx context.Context, in *nextgenv1.ListBackupPoliciesRequest, opts ...grpc.CallOption) (*nextgenv1.ListBackupPoliciesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBackupPolicies", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListBackupPoliciesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBackupPolicies indicates an expected call of ListBackupPolicies.
func (mr *MockNextGenGlobalMockRecorder) ListBackupPolicies(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBackupPolicies", reflect.TypeOf((*MockNextGenGlobal)(nil).ListBackupPolicies), varargs...)
}

// ListBackups mocks base method.
func (m *MockNextGenGlobal) ListBackups(ctx context.Context, in *nextgenv1.ListBackupsRequest, opts ...grpc.CallOption) (*nextgenv1.ListBackupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBackups", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListBackupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBackups indicates an expected call of ListBackups.
func (mr *MockNextGenGlobalMockRecorder) ListBackups(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBackups", reflect.TypeOf((*MockNextGenGlobal)(nil).ListBackups), varargs...)
}

// ListByocVcpuPools mocks base method.
func (m *MockNextGenGlobal) ListByocVcpuPools(ctx context.Context, in *nextgenv1.ListByocVcpuPoolsRequest, opts ...grpc.CallOption) (*nextgenv1.ListByocVcpuPoolsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListByocVcpuPools", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListByocVcpuPoolsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListByocVcpuPools indicates an expected call of ListByocVcpuPools.
func (mr *MockNextGenGlobalMockRecorder) ListByocVcpuPools(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByocVcpuPools", reflect.TypeOf((*MockNextGenGlobal)(nil).ListByocVcpuPools), varargs...)
}

// ListCloudProviders mocks base method.
func (m *MockNextGenGlobal) ListCloudProviders(ctx context.Context, in *nextgenv1.ListCloudProvidersRequest, opts ...grpc.CallOption) (*nextgenv1.ListCloudProvidersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCloudProviders", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListCloudProvidersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCloudProviders indicates an expected call of ListCloudProviders.
func (mr *MockNextGenGlobalMockRecorder) ListCloudProviders(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCloudProviders", reflect.TypeOf((*MockNextGenGlobal)(nil).ListCloudProviders), varargs...)
}

// ListClusterBackups mocks base method.
func (m *MockNextGenGlobal) ListClusterBackups(ctx context.Context, in *nextgenv1.ListClusterBackupsRequest, opts ...grpc.CallOption) (*nextgenv1.ListClusterBackupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusterBackups", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListClusterBackupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterBackups indicates an expected call of ListClusterBackups.
func (mr *MockNextGenGlobalMockRecorder) ListClusterBackups(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterBackups", reflect.TypeOf((*MockNextGenGlobal)(nil).ListClusterBackups), varargs...)
}

// ListClusters mocks base method.
func (m *MockNextGenGlobal) ListClusters(ctx context.Context, in *nextgenv1.ListClustersRequest, opts ...grpc.CallOption) (*nextgenv1.ListClustersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusters", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusters indicates an expected call of ListClusters.
func (mr *MockNextGenGlobalMockRecorder) ListClusters(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockNextGenGlobal)(nil).ListClusters), varargs...)
}

// ListCustomerManagedEncryptionKeys mocks base method.
func (m *MockNextGenGlobal) ListCustomerManagedEncryptionKeys(ctx context.Context, in *nextgenv1.ListCustomerManagedEncryptionKeysRequest, opts ...grpc.CallOption) (*nextgenv1.ListCustomerManagedEncryptionKeysResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCustomerManagedEncryptionKeys", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListCustomerManagedEncryptionKeysResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCustomerManagedEncryptionKeys indicates an expected call of ListCustomerManagedEncryptionKeys.
func (mr *MockNextGenGlobalMockRecorder) ListCustomerManagedEncryptionKeys(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomerManagedEncryptionKeys", reflect.TypeOf((*MockNextGenGlobal)(nil).ListCustomerManagedEncryptionKeys), varargs...)
}

// ListExports mocks base method.
func (m *MockNextGenGlobal) ListExports(ctx context.Context, in *nextgenv1.ListExportsRequest, opts ...grpc.CallOption) (*nextgenv1.ListExportsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListExports", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListExportsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListExports indicates an expected call of ListExports.
func (mr *MockNextGenGlobalMockRecorder) ListExports(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExports", reflect.TypeOf((*MockNextGenGlobal)(nil).ListExports), varargs...)
}

// ListNodeSpecs mocks base method.
func (m *MockNextGenGlobal) ListNodeSpecs(ctx context.Context, in *nextgenv1.ListNodeSpecsRequest, opts ...grpc.CallOption) (*nextgenv1.ListNodeSpecsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNodeSpecs", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListNodeSpecsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNodeSpecs indicates an expected call of ListNodeSpecs.
func (mr *MockNextGenGlobalMockRecorder) ListNodeSpecs(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodeSpecs", reflect.TypeOf((*MockNextGenGlobal)(nil).ListNodeSpecs), varargs...)
}

// ListNotCleanupBackupSettings mocks base method.
func (m *MockNextGenGlobal) ListNotCleanupBackupSettings(ctx context.Context, in *nextgenv1.ListNotCleanupBackupSettingsRequest, opts ...grpc.CallOption) (*nextgenv1.ListNotCleanupBackupSettingsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNotCleanupBackupSettings", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListNotCleanupBackupSettingsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNotCleanupBackupSettings indicates an expected call of ListNotCleanupBackupSettings.
func (mr *MockNextGenGlobalMockRecorder) ListNotCleanupBackupSettings(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNotCleanupBackupSettings", reflect.TypeOf((*MockNextGenGlobal)(nil).ListNotCleanupBackupSettings), varargs...)
}

// ListOrgRcuQuotas mocks base method.
func (m *MockNextGenGlobal) ListOrgRcuQuotas(ctx context.Context, in *nextgenv1.ListOrgRcuQuotasRequest, opts ...grpc.CallOption) (*nextgenv1.ListOrgRcuQuotasResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOrgRcuQuotas", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListOrgRcuQuotasResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOrgRcuQuotas indicates an expected call of ListOrgRcuQuotas.
func (mr *MockNextGenGlobalMockRecorder) ListOrgRcuQuotas(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOrgRcuQuotas", reflect.TypeOf((*MockNextGenGlobal)(nil).ListOrgRcuQuotas), varargs...)
}

// ListOwnerResourcePools mocks base method.
func (m *MockNextGenGlobal) ListOwnerResourcePools(ctx context.Context, in *nextgenv1.ListOwnerResourcePoolsRequest, opts ...grpc.CallOption) (*nextgenv1.ListOwnerResourcePoolsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOwnerResourcePools", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListOwnerResourcePoolsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOwnerResourcePools indicates an expected call of ListOwnerResourcePools.
func (mr *MockNextGenGlobalMockRecorder) ListOwnerResourcePools(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOwnerResourcePools", reflect.TypeOf((*MockNextGenGlobal)(nil).ListOwnerResourcePools), varargs...)
}

// ListPrivateLinkConnections mocks base method.
func (m *MockNextGenGlobal) ListPrivateLinkConnections(ctx context.Context, in *nextgenv1.ListPrivateLinkConnectionsRequest, opts ...grpc.CallOption) (*nextgenv1.ListPrivateLinkConnectionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPrivateLinkConnections", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListPrivateLinkConnectionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPrivateLinkConnections indicates an expected call of ListPrivateLinkConnections.
func (mr *MockNextGenGlobalMockRecorder) ListPrivateLinkConnections(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPrivateLinkConnections", reflect.TypeOf((*MockNextGenGlobal)(nil).ListPrivateLinkConnections), varargs...)
}

// ListPrivateLinkServices mocks base method.
func (m *MockNextGenGlobal) ListPrivateLinkServices(ctx context.Context, in *nextgenv1.ListPrivateLinkServicesRequest, opts ...grpc.CallOption) (*nextgenv1.ListPrivateLinkServicesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPrivateLinkServices", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListPrivateLinkServicesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPrivateLinkServices indicates an expected call of ListPrivateLinkServices.
func (mr *MockNextGenGlobalMockRecorder) ListPrivateLinkServices(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPrivateLinkServices", reflect.TypeOf((*MockNextGenGlobal)(nil).ListPrivateLinkServices), varargs...)
}

// ListRegionCapacities mocks base method.
func (m *MockNextGenGlobal) ListRegionCapacities(ctx context.Context, in *nextgenv1.ListRegionCapacitiesRequest, opts ...grpc.CallOption) (*nextgenv1.ListRegionCapacitiesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRegionCapacities", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListRegionCapacitiesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRegionCapacities indicates an expected call of ListRegionCapacities.
func (mr *MockNextGenGlobalMockRecorder) ListRegionCapacities(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegionCapacities", reflect.TypeOf((*MockNextGenGlobal)(nil).ListRegionCapacities), varargs...)
}

// ListRegionProviderIdentities mocks base method.
func (m *MockNextGenGlobal) ListRegionProviderIdentities(ctx context.Context, in *nextgenv1.ListRegionProviderIdentitiesRequest, opts ...grpc.CallOption) (*nextgenv1.ListRegionProviderIdentitiesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRegionProviderIdentities", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListRegionProviderIdentitiesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRegionProviderIdentities indicates an expected call of ListRegionProviderIdentities.
func (mr *MockNextGenGlobalMockRecorder) ListRegionProviderIdentities(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegionProviderIdentities", reflect.TypeOf((*MockNextGenGlobal)(nil).ListRegionProviderIdentities), varargs...)
}

// ListRegions mocks base method.
func (m *MockNextGenGlobal) ListRegions(ctx context.Context, in *nextgenv1.ListRegionsRequest, opts ...grpc.CallOption) (*nextgenv1.ListRegionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRegions", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListRegionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRegions indicates an expected call of ListRegions.
func (mr *MockNextGenGlobalMockRecorder) ListRegions(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegions", reflect.TypeOf((*MockNextGenGlobal)(nil).ListRegions), varargs...)
}

// ListReservedCapacityTemplates mocks base method.
func (m *MockNextGenGlobal) ListReservedCapacityTemplates(ctx context.Context, in *nextgenv1.ListReservedCapacityTemplatesRequest, opts ...grpc.CallOption) (*nextgenv1.ListReservedCapacityTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListReservedCapacityTemplates", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListReservedCapacityTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListReservedCapacityTemplates indicates an expected call of ListReservedCapacityTemplates.
func (mr *MockNextGenGlobalMockRecorder) ListReservedCapacityTemplates(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReservedCapacityTemplates", reflect.TypeOf((*MockNextGenGlobal)(nil).ListReservedCapacityTemplates), varargs...)
}

// ListResourcePools mocks base method.
func (m *MockNextGenGlobal) ListResourcePools(ctx context.Context, in *nextgenv1.ListResourcePoolsRequest, opts ...grpc.CallOption) (*nextgenv1.ListResourcePoolsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListResourcePools", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListResourcePoolsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListResourcePools indicates an expected call of ListResourcePools.
func (mr *MockNextGenGlobalMockRecorder) ListResourcePools(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourcePools", reflect.TypeOf((*MockNextGenGlobal)(nil).ListResourcePools), varargs...)
}

// ListVpcPeerings mocks base method.
func (m *MockNextGenGlobal) ListVpcPeerings(ctx context.Context, in *nextgenv1.ListVpcPeeringsRequest, opts ...grpc.CallOption) (*nextgenv1.ListVpcPeeringsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVpcPeerings", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ListVpcPeeringsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVpcPeerings indicates an expected call of ListVpcPeerings.
func (mr *MockNextGenGlobalMockRecorder) ListVpcPeerings(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVpcPeerings", reflect.TypeOf((*MockNextGenGlobal)(nil).ListVpcPeerings), varargs...)
}

// OverrideFlexibleBackupRetention mocks base method.
func (m *MockNextGenGlobal) OverrideFlexibleBackupRetention(ctx context.Context, in *nextgenv1.OverrideFlexibleBackupRetentionRequest, opts ...grpc.CallOption) (*nextgenv1.BackupSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OverrideFlexibleBackupRetention", varargs...)
	ret0, _ := ret[0].(*nextgenv1.BackupSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OverrideFlexibleBackupRetention indicates an expected call of OverrideFlexibleBackupRetention.
func (mr *MockNextGenGlobalMockRecorder) OverrideFlexibleBackupRetention(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverrideFlexibleBackupRetention", reflect.TypeOf((*MockNextGenGlobal)(nil).OverrideFlexibleBackupRetention), varargs...)
}

// PauseResourcePool mocks base method.
func (m *MockNextGenGlobal) PauseResourcePool(ctx context.Context, in *nextgenv1.PauseResourcePoolRequest, opts ...grpc.CallOption) (*nextgenv1.PauseResourcePoolResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PauseResourcePool", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PauseResourcePoolResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PauseResourcePool indicates an expected call of PauseResourcePool.
func (mr *MockNextGenGlobalMockRecorder) PauseResourcePool(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseResourcePool", reflect.TypeOf((*MockNextGenGlobal)(nil).PauseResourcePool), varargs...)
}

// PlanResourcePoolCidr mocks base method.
func (m *MockNextGenGlobal) PlanResourcePoolCidr(ctx context.Context, in *nextgenv1.PlanResourcePoolCidrRequest, opts ...grpc.CallOption) (*nextgenv1.PlanResourcePoolCidrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PlanResourcePoolCidr", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PlanResourcePoolCidrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PlanResourcePoolCidr indicates an expected call of PlanResourcePoolCidr.
func (mr *MockNextGenGlobalMockRecorder) PlanResourcePoolCidr(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PlanResourcePoolCidr", reflect.TypeOf((*MockNextGenGlobal)(nil).PlanResourcePoolCidr), varargs...)
}

// RegisterCloudProvider mocks base method.
func (m *MockNextGenGlobal) RegisterCloudProvider(ctx context.Context, in *nextgenv1.RegisterCloudProviderRequest, opts ...grpc.CallOption) (*commonv1.CloudProvider, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterCloudProvider", varargs...)
	ret0, _ := ret[0].(*commonv1.CloudProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterCloudProvider indicates an expected call of RegisterCloudProvider.
func (mr *MockNextGenGlobalMockRecorder) RegisterCloudProvider(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCloudProvider", reflect.TypeOf((*MockNextGenGlobal)(nil).RegisterCloudProvider), varargs...)
}

// RegisterRegion mocks base method.
func (m *MockNextGenGlobal) RegisterRegion(ctx context.Context, in *nextgenv1.RegisterRegionRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterRegion", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterRegion indicates an expected call of RegisterRegion.
func (mr *MockNextGenGlobalMockRecorder) RegisterRegion(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRegion", reflect.TypeOf((*MockNextGenGlobal)(nil).RegisterRegion), varargs...)
}

// RegisterRegionProviderIdentity mocks base method.
func (m *MockNextGenGlobal) RegisterRegionProviderIdentity(ctx context.Context, in *nextgenv1.RegisterRegionProviderIdentityRequest, opts ...grpc.CallOption) (*nextgenv1.RegionProviderIdentity, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterRegionProviderIdentity", varargs...)
	ret0, _ := ret[0].(*nextgenv1.RegionProviderIdentity)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterRegionProviderIdentity indicates an expected call of RegisterRegionProviderIdentity.
func (mr *MockNextGenGlobalMockRecorder) RegisterRegionProviderIdentity(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRegionProviderIdentity", reflect.TypeOf((*MockNextGenGlobal)(nil).RegisterRegionProviderIdentity), varargs...)
}

// ResizeResourcePoolCapacity mocks base method.
func (m *MockNextGenGlobal) ResizeResourcePoolCapacity(ctx context.Context, in *nextgenv1.ResizeResourcePoolCapacityRequest, opts ...grpc.CallOption) (*nextgenv1.ResizeResourcePoolCapacityResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResizeResourcePoolCapacity", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResizeResourcePoolCapacityResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResizeResourcePoolCapacity indicates an expected call of ResizeResourcePoolCapacity.
func (mr *MockNextGenGlobalMockRecorder) ResizeResourcePoolCapacity(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizeResourcePoolCapacity", reflect.TypeOf((*MockNextGenGlobal)(nil).ResizeResourcePoolCapacity), varargs...)
}

// ResolvePauseResourcePoolAdmission mocks base method.
func (m *MockNextGenGlobal) ResolvePauseResourcePoolAdmission(ctx context.Context, in *nextgenv1.ResolvePauseResourcePoolAdmissionRequest, opts ...grpc.CallOption) (*nextgenv1.ResolvePauseResourcePoolAdmissionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResolvePauseResourcePoolAdmission", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResolvePauseResourcePoolAdmissionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolvePauseResourcePoolAdmission indicates an expected call of ResolvePauseResourcePoolAdmission.
func (mr *MockNextGenGlobalMockRecorder) ResolvePauseResourcePoolAdmission(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolvePauseResourcePoolAdmission", reflect.TypeOf((*MockNextGenGlobal)(nil).ResolvePauseResourcePoolAdmission), varargs...)
}

// RestoreCluster mocks base method.
func (m *MockNextGenGlobal) RestoreCluster(ctx context.Context, in *nextgenv1.RestoreClusterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreCluster", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreCluster indicates an expected call of RestoreCluster.
func (mr *MockNextGenGlobalMockRecorder) RestoreCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreCluster", reflect.TypeOf((*MockNextGenGlobal)(nil).RestoreCluster), varargs...)
}

// RestoreStatus mocks base method.
func (m *MockNextGenGlobal) RestoreStatus(ctx context.Context, in *nextgenv1.RestoreStatusRequest, opts ...grpc.CallOption) (*nextgenv1.RestoreStatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreStatus", varargs...)
	ret0, _ := ret[0].(*nextgenv1.RestoreStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreStatus indicates an expected call of RestoreStatus.
func (mr *MockNextGenGlobalMockRecorder) RestoreStatus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreStatus", reflect.TypeOf((*MockNextGenGlobal)(nil).RestoreStatus), varargs...)
}

// ResumeResourcePool mocks base method.
func (m *MockNextGenGlobal) ResumeResourcePool(ctx context.Context, in *nextgenv1.ResumeResourcePoolRequest, opts ...grpc.CallOption) (*nextgenv1.ResumeResourcePoolResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResumeResourcePool", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResumeResourcePoolResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResumeResourcePool indicates an expected call of ResumeResourcePool.
func (mr *MockNextGenGlobalMockRecorder) ResumeResourcePool(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeResourcePool", reflect.TypeOf((*MockNextGenGlobal)(nil).ResumeResourcePool), varargs...)
}

// ScaleByocSharedComponents mocks base method.
func (m *MockNextGenGlobal) ScaleByocSharedComponents(ctx context.Context, in *nextgenv1.ScaleByocSharedComponentsRequest, opts ...grpc.CallOption) (*nextgenv1.ScaleByocSharedComponentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScaleByocSharedComponents", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ScaleByocSharedComponentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ScaleByocSharedComponents indicates an expected call of ScaleByocSharedComponents.
func (mr *MockNextGenGlobalMockRecorder) ScaleByocSharedComponents(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScaleByocSharedComponents", reflect.TypeOf((*MockNextGenGlobal)(nil).ScaleByocSharedComponents), varargs...)
}

// SelectRegionByOrgId mocks base method.
func (m *MockNextGenGlobal) SelectRegionByOrgId(ctx context.Context, in *nextgenv1.SelectRegionByOrgIdRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SelectRegionByOrgId", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectRegionByOrgId indicates an expected call of SelectRegionByOrgId.
func (mr *MockNextGenGlobalMockRecorder) SelectRegionByOrgId(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectRegionByOrgId", reflect.TypeOf((*MockNextGenGlobal)(nil).SelectRegionByOrgId), varargs...)
}

// StopRestoreCluster mocks base method.
func (m *MockNextGenGlobal) StopRestoreCluster(ctx context.Context, in *nextgenv1.StopRestoreClusterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopRestoreCluster", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopRestoreCluster indicates an expected call of StopRestoreCluster.
func (mr *MockNextGenGlobalMockRecorder) StopRestoreCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopRestoreCluster", reflect.TypeOf((*MockNextGenGlobal)(nil).StopRestoreCluster), varargs...)
}

// TestClassicBackupAccess mocks base method.
func (m *MockNextGenGlobal) TestClassicBackupAccess(ctx context.Context, in *nextgenv1.TestClassicBackupAccessRequest, opts ...grpc.CallOption) (*nextgenv1.TestClassicBackupAccessResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TestClassicBackupAccess", varargs...)
	ret0, _ := ret[0].(*nextgenv1.TestClassicBackupAccessResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TestClassicBackupAccess indicates an expected call of TestClassicBackupAccess.
func (mr *MockNextGenGlobalMockRecorder) TestClassicBackupAccess(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestClassicBackupAccess", reflect.TypeOf((*MockNextGenGlobal)(nil).TestClassicBackupAccess), varargs...)
}

// UpdateAuditLogFilterRule mocks base method.
func (m *MockNextGenGlobal) UpdateAuditLogFilterRule(ctx context.Context, in *nextgenv1.UpdateAuditLogFilterRuleRequest, opts ...grpc.CallOption) (*nextgenv1.AuditLogFilterRule, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAuditLogFilterRule", varargs...)
	ret0, _ := ret[0].(*nextgenv1.AuditLogFilterRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAuditLogFilterRule indicates an expected call of UpdateAuditLogFilterRule.
func (mr *MockNextGenGlobalMockRecorder) UpdateAuditLogFilterRule(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuditLogFilterRule", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateAuditLogFilterRule), varargs...)
}

// UpdateAuditLogSetting mocks base method.
func (m *MockNextGenGlobal) UpdateAuditLogSetting(ctx context.Context, in *nextgenv1.UpdateAuditLogSettingRequest, opts ...grpc.CallOption) (*nextgenv1.AuditLogSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAuditLogSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.AuditLogSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAuditLogSetting indicates an expected call of UpdateAuditLogSetting.
func (mr *MockNextGenGlobalMockRecorder) UpdateAuditLogSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuditLogSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateAuditLogSetting), varargs...)
}

// UpdateBackupSetting mocks base method.
func (m *MockNextGenGlobal) UpdateBackupSetting(ctx context.Context, in *nextgenv1.UpdateBackupSettingRequest, opts ...grpc.CallOption) (*nextgenv1.BackupSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateBackupSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.BackupSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBackupSetting indicates an expected call of UpdateBackupSetting.
func (mr *MockNextGenGlobalMockRecorder) UpdateBackupSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBackupSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateBackupSetting), varargs...)
}

// UpdateCluster mocks base method.
func (m *MockNextGenGlobal) UpdateCluster(ctx context.Context, in *nextgenv1.UpdateClusterRequest, opts ...grpc.CallOption) (*nextgenv1.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateCluster", varargs...)
	ret0, _ := ret[0].(*nextgenv1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCluster indicates an expected call of UpdateCluster.
func (mr *MockNextGenGlobalMockRecorder) UpdateCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateCluster), varargs...)
}

// UpdateClusterDualLayerEncryption mocks base method.
func (m *MockNextGenGlobal) UpdateClusterDualLayerEncryption(ctx context.Context, in *nextgenv1.UpdateClusterDualLayerEncryptionRequest, opts ...grpc.CallOption) (*nextgenv1.UpdateClusterDualLayerEncryptionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateClusterDualLayerEncryption", varargs...)
	ret0, _ := ret[0].(*nextgenv1.UpdateClusterDualLayerEncryptionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterDualLayerEncryption indicates an expected call of UpdateClusterDualLayerEncryption.
func (mr *MockNextGenGlobalMockRecorder) UpdateClusterDualLayerEncryption(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterDualLayerEncryption", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateClusterDualLayerEncryption), varargs...)
}

// UpdateClusterProject mocks base method.
func (m *MockNextGenGlobal) UpdateClusterProject(ctx context.Context, in *nextgenv1.UpdateClusterProjectRequest, opts ...grpc.CallOption) (*nextgenv1.UpdateClusterProjectResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateClusterProject", varargs...)
	ret0, _ := ret[0].(*nextgenv1.UpdateClusterProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterProject indicates an expected call of UpdateClusterProject.
func (mr *MockNextGenGlobalMockRecorder) UpdateClusterProject(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterProject", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateClusterProject), varargs...)
}

// UpdateLogRedactionPolicy mocks base method.
func (m *MockNextGenGlobal) UpdateLogRedactionPolicy(ctx context.Context, in *nextgenv1.UpdateLogRedactionPolicyRequest, opts ...grpc.CallOption) (*nextgenv1.LogRedactionPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateLogRedactionPolicy", varargs...)
	ret0, _ := ret[0].(*nextgenv1.LogRedactionPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLogRedactionPolicy indicates an expected call of UpdateLogRedactionPolicy.
func (mr *MockNextGenGlobalMockRecorder) UpdateLogRedactionPolicy(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogRedactionPolicy", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateLogRedactionPolicy), varargs...)
}

// UpdateOrgDefaultResourcePool mocks base method.
func (m *MockNextGenGlobal) UpdateOrgDefaultResourcePool(ctx context.Context, in *nextgenv1.UpdateOrgDefaultResourcePoolRequest, opts ...grpc.CallOption) (*nextgenv1.ResourcePoolStrategy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateOrgDefaultResourcePool", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResourcePoolStrategy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOrgDefaultResourcePool indicates an expected call of UpdateOrgDefaultResourcePool.
func (mr *MockNextGenGlobalMockRecorder) UpdateOrgDefaultResourcePool(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrgDefaultResourcePool", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateOrgDefaultResourcePool), varargs...)
}

// UpdatePlanReplayerStatus mocks base method.
func (m *MockNextGenGlobal) UpdatePlanReplayerStatus(ctx context.Context, in *nextgenv1.UpdatePlanReplayerStatusRequest, opts ...grpc.CallOption) (*nextgenv1.PlanReplayerStatus, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePlanReplayerStatus", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PlanReplayerStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePlanReplayerStatus indicates an expected call of UpdatePlanReplayerStatus.
func (mr *MockNextGenGlobalMockRecorder) UpdatePlanReplayerStatus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePlanReplayerStatus", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdatePlanReplayerStatus), varargs...)
}

// UpdatePublicConnectionSetting mocks base method.
func (m *MockNextGenGlobal) UpdatePublicConnectionSetting(ctx context.Context, in *nextgenv1.UpdatePublicConnectionSettingRequest, opts ...grpc.CallOption) (*nextgenv1.PublicConnectionSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePublicConnectionSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.PublicConnectionSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePublicConnectionSetting indicates an expected call of UpdatePublicConnectionSetting.
func (mr *MockNextGenGlobalMockRecorder) UpdatePublicConnectionSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePublicConnectionSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdatePublicConnectionSetting), varargs...)
}

// UpdateRcuQuota mocks base method.
func (m *MockNextGenGlobal) UpdateRcuQuota(ctx context.Context, in *nextgenv1.UpdateRcuQuotaRequest, opts ...grpc.CallOption) (*nextgenv1.RcuQuota, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRcuQuota", varargs...)
	ret0, _ := ret[0].(*nextgenv1.RcuQuota)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRcuQuota indicates an expected call of UpdateRcuQuota.
func (mr *MockNextGenGlobalMockRecorder) UpdateRcuQuota(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRcuQuota", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateRcuQuota), varargs...)
}

// UpdateRegion mocks base method.
func (m *MockNextGenGlobal) UpdateRegion(ctx context.Context, in *nextgenv1.UpdateRegionRequest, opts ...grpc.CallOption) (*commonv1.Region, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRegion", varargs...)
	ret0, _ := ret[0].(*commonv1.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRegion indicates an expected call of UpdateRegion.
func (mr *MockNextGenGlobalMockRecorder) UpdateRegion(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRegion", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateRegion), varargs...)
}

// UpdateRegionOpsAuditLogSetting mocks base method.
func (m *MockNextGenGlobal) UpdateRegionOpsAuditLogSetting(ctx context.Context, in *nextgenv1.UpdateRegionOpsAuditLogSettingRequest, opts ...grpc.CallOption) (*nextgenv1.UpdateRegionOpsAuditLogSettingResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRegionOpsAuditLogSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.UpdateRegionOpsAuditLogSettingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRegionOpsAuditLogSetting indicates an expected call of UpdateRegionOpsAuditLogSetting.
func (mr *MockNextGenGlobalMockRecorder) UpdateRegionOpsAuditLogSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRegionOpsAuditLogSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateRegionOpsAuditLogSetting), varargs...)
}

// UpdateReservedCapacityTemplateStatus mocks base method.
func (m *MockNextGenGlobal) UpdateReservedCapacityTemplateStatus(ctx context.Context, in *nextgenv1.UpdateReservedCapacityTemplateStatusRequest, opts ...grpc.CallOption) (*nextgenv1.ReservedCapacityTemplate, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateReservedCapacityTemplateStatus", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ReservedCapacityTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateReservedCapacityTemplateStatus indicates an expected call of UpdateReservedCapacityTemplateStatus.
func (mr *MockNextGenGlobalMockRecorder) UpdateReservedCapacityTemplateStatus(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateReservedCapacityTemplateStatus", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateReservedCapacityTemplateStatus), varargs...)
}

// UpdateResourcePoolInstanceLimit mocks base method.
func (m *MockNextGenGlobal) UpdateResourcePoolInstanceLimit(ctx context.Context, in *nextgenv1.UpdateResourcePoolInstanceLimitRequest, opts ...grpc.CallOption) (*nextgenv1.ResourcePool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateResourcePoolInstanceLimit", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResourcePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateResourcePoolInstanceLimit indicates an expected call of UpdateResourcePoolInstanceLimit.
func (mr *MockNextGenGlobalMockRecorder) UpdateResourcePoolInstanceLimit(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResourcePoolInstanceLimit", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateResourcePoolInstanceLimit), varargs...)
}

// UpdateResourcePoolName mocks base method.
func (m *MockNextGenGlobal) UpdateResourcePoolName(ctx context.Context, in *nextgenv1.UpdateResourcePoolNameRequest, opts ...grpc.CallOption) (*nextgenv1.ResourcePool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateResourcePoolName", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ResourcePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateResourcePoolName indicates an expected call of UpdateResourcePoolName.
func (mr *MockNextGenGlobalMockRecorder) UpdateResourcePoolName(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResourcePoolName", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateResourcePoolName), varargs...)
}

// UpdateVpcPeeringAllowlistSetting mocks base method.
func (m *MockNextGenGlobal) UpdateVpcPeeringAllowlistSetting(ctx context.Context, in *nextgenv1.UpdateVpcPeeringAllowlistSettingRequest, opts ...grpc.CallOption) (*nextgenv1.VpcPeeringAllowlistSetting, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateVpcPeeringAllowlistSetting", varargs...)
	ret0, _ := ret[0].(*nextgenv1.VpcPeeringAllowlistSetting)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateVpcPeeringAllowlistSetting indicates an expected call of UpdateVpcPeeringAllowlistSetting.
func (mr *MockNextGenGlobalMockRecorder) UpdateVpcPeeringAllowlistSetting(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVpcPeeringAllowlistSetting", reflect.TypeOf((*MockNextGenGlobal)(nil).UpdateVpcPeeringAllowlistSetting), varargs...)
}

// UpsertResourcePoolCloudResourceTags mocks base method.
func (m *MockNextGenGlobal) UpsertResourcePoolCloudResourceTags(ctx context.Context, in *nextgenv1.UpsertResourcePoolCloudResourceTagsRequest, opts ...grpc.CallOption) (*nextgenv1.UpsertResourcePoolCloudResourceTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpsertResourcePoolCloudResourceTags", varargs...)
	ret0, _ := ret[0].(*nextgenv1.UpsertResourcePoolCloudResourceTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertResourcePoolCloudResourceTags indicates an expected call of UpsertResourcePoolCloudResourceTags.
func (mr *MockNextGenGlobalMockRecorder) UpsertResourcePoolCloudResourceTags(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertResourcePoolCloudResourceTags", reflect.TypeOf((*MockNextGenGlobal)(nil).UpsertResourcePoolCloudResourceTags), varargs...)
}

// ValidateResourcePoolCidr mocks base method.
func (m *MockNextGenGlobal) ValidateResourcePoolCidr(ctx context.Context, in *nextgenv1.ValidateResourcePoolCidrRequest, opts ...grpc.CallOption) (*nextgenv1.ValidateResourcePoolCidrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateResourcePoolCidr", varargs...)
	ret0, _ := ret[0].(*nextgenv1.ValidateResourcePoolCidrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateResourcePoolCidr indicates an expected call of ValidateResourcePoolCidr.
func (mr *MockNextGenGlobalMockRecorder) ValidateResourcePoolCidr(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateResourcePoolCidr", reflect.TypeOf((*MockNextGenGlobal)(nil).ValidateResourcePoolCidr), varargs...)
}

// VerifyCmekAccessIamPrincipal mocks base method.
func (m *MockNextGenGlobal) VerifyCmekAccessIamPrincipal(ctx context.Context, in *nextgenv1.VerifyCmekAccessIamPrincipalRequest, opts ...grpc.CallOption) (*nextgenv1.VerifyCmekAccessIamPrincipalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyCmekAccessIamPrincipal", varargs...)
	ret0, _ := ret[0].(*nextgenv1.VerifyCmekAccessIamPrincipalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyCmekAccessIamPrincipal indicates an expected call of VerifyCmekAccessIamPrincipal.
func (mr *MockNextGenGlobalMockRecorder) VerifyCmekAccessIamPrincipal(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyCmekAccessIamPrincipal", reflect.TypeOf((*MockNextGenGlobal)(nil).VerifyCmekAccessIamPrincipal), varargs...)
}