// Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/domain/facade/infra.go
//
// Generated by this command:
//
//	mockgen -source=./internal/domain/facade/infra.go -destination ./internal/domain/facade/mock_facade/mock_infra.go -package mock_facade
//

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

import (
	context "context"
	reflect "reflect"

	v1 "github.com/tidbcloud/infra-api/api/v1"
	gomock "go.uber.org/mock/gomock"
)

// MockInfraFacade is a mock of InfraFacade interface.
type MockInfraFacade struct {
	ctrl     *gomock.Controller
	recorder *MockInfraFacadeMockRecorder
}

// MockInfraFacadeMockRecorder is the mock recorder for MockInfraFacade.
type MockInfraFacadeMockRecorder struct {
	mock *MockInfraFacade
}

// NewMockInfraFacade creates a new mock instance.
func NewMockInfraFacade(ctrl *gomock.Controller) *MockInfraFacade {
	mock := &MockInfraFacade{ctrl: ctrl}
	mock.recorder = &MockInfraFacadeMockRecorder{mock}
	return mock
}

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

// CreateBranch mocks base method.
func (m *MockInfraFacade) CreateBranch(ctx context.Context, b *v1.Branch) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBranch", ctx, b)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateBranch indicates an expected call of CreateBranch.
func (mr *MockInfraFacadeMockRecorder) CreateBranch(ctx, b any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBranch", reflect.TypeOf((*MockInfraFacade)(nil).CreateBranch), ctx, b)
}

// CreateExport mocks base method.
func (m *MockInfraFacade) CreateExport(ctx context.Context, proxyEndpoint string, e *v1.Export) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateExport", ctx, proxyEndpoint, e)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateExport indicates an expected call of CreateExport.
func (mr *MockInfraFacadeMockRecorder) CreateExport(ctx, proxyEndpoint, e any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExport", reflect.TypeOf((*MockInfraFacade)(nil).CreateExport), ctx, proxyEndpoint, e)
}

// CreateImportIgnoreExists mocks base method.
func (m *MockInfraFacade) CreateImportIgnoreExists(ctx context.Context, proxyEndpoint string, cr *v1.Import) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImportIgnoreExists", ctx, proxyEndpoint, cr)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateImportIgnoreExists indicates an expected call of CreateImportIgnoreExists.
func (mr *MockInfraFacadeMockRecorder) CreateImportIgnoreExists(ctx, proxyEndpoint, cr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImportIgnoreExists", reflect.TypeOf((*MockInfraFacade)(nil).CreateImportIgnoreExists), ctx, proxyEndpoint, cr)
}

// DeleteBranch mocks base method.
func (m *MockInfraFacade) DeleteBranch(ctx context.Context, projectID uint64, branchID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBranch", ctx, projectID, branchID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBranch indicates an expected call of DeleteBranch.
func (mr *MockInfraFacadeMockRecorder) DeleteBranch(ctx, projectID, branchID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBranch", reflect.TypeOf((*MockInfraFacade)(nil).DeleteBranch), ctx, projectID, branchID)
}

// DeleteExport mocks base method.
func (m *MockInfraFacade) DeleteExport(ctx context.Context, proxyEndpoint string, projectID uint64, exportID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteExport", ctx, proxyEndpoint, projectID, exportID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteExport indicates an expected call of DeleteExport.
func (mr *MockInfraFacadeMockRecorder) DeleteExport(ctx, proxyEndpoint, projectID, exportID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExport", reflect.TypeOf((*MockInfraFacade)(nil).DeleteExport), ctx, proxyEndpoint, projectID, exportID)
}

// DeleteImport mocks base method.
func (m *MockInfraFacade) DeleteImport(ctx context.Context, proxyEndpoint string, projectID uint64, importID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteImport", ctx, proxyEndpoint, projectID, importID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteImport indicates an expected call of DeleteImport.
func (mr *MockInfraFacadeMockRecorder) DeleteImport(ctx, proxyEndpoint, projectID, importID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImport", reflect.TypeOf((*MockInfraFacade)(nil).DeleteImport), ctx, proxyEndpoint, projectID, importID)
}

// GetBranch mocks base method.
func (m *MockInfraFacade) GetBranch(ctx context.Context, projectId uint64, branchId string) (*v1.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranch", ctx, projectId, branchId)
	ret0, _ := ret[0].(*v1.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBranch indicates an expected call of GetBranch.
func (mr *MockInfraFacadeMockRecorder) GetBranch(ctx, projectId, branchId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranch", reflect.TypeOf((*MockInfraFacade)(nil).GetBranch), ctx, projectId, branchId)
}

// GetBranchDirectly mocks base method.
func (m *MockInfraFacade) GetBranchDirectly(ctx context.Context, projectId uint64, branchId string) (*v1.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranchDirectly", ctx, projectId, branchId)
	ret0, _ := ret[0].(*v1.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBranchDirectly indicates an expected call of GetBranchDirectly.
func (mr *MockInfraFacadeMockRecorder) GetBranchDirectly(ctx, projectId, branchId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranchDirectly", reflect.TypeOf((*MockInfraFacade)(nil).GetBranchDirectly), ctx, projectId, branchId)
}

// GetExport mocks base method.
func (m *MockInfraFacade) GetExport(ctx context.Context, proxyEndpoint string, projectId uint64, exportId string) (*v1.Export, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExport", ctx, proxyEndpoint, projectId, exportId)
	ret0, _ := ret[0].(*v1.Export)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExport indicates an expected call of GetExport.
func (mr *MockInfraFacadeMockRecorder) GetExport(ctx, proxyEndpoint, projectId, exportId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExport", reflect.TypeOf((*MockInfraFacade)(nil).GetExport), ctx, proxyEndpoint, projectId, exportId)
}

// GetExportDirectly mocks base method.
func (m *MockInfraFacade) GetExportDirectly(ctx context.Context, proxyEndpoint string, projectId uint64, exportId string) (*v1.Export, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExportDirectly", ctx, proxyEndpoint, projectId, exportId)
	ret0, _ := ret[0].(*v1.Export)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExportDirectly indicates an expected call of GetExportDirectly.
func (mr *MockInfraFacadeMockRecorder) GetExportDirectly(ctx, proxyEndpoint, projectId, exportId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExportDirectly", reflect.TypeOf((*MockInfraFacade)(nil).GetExportDirectly), ctx, proxyEndpoint, projectId, exportId)
}

// GetImport mocks base method.
func (m *MockInfraFacade) GetImport(ctx context.Context, proxyEndpoint string, projectID uint64, importID string) (*v1.Import, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImport", ctx, proxyEndpoint, projectID, importID)
	ret0, _ := ret[0].(*v1.Import)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImport indicates an expected call of GetImport.
func (mr *MockInfraFacadeMockRecorder) GetImport(ctx, proxyEndpoint, projectID, importID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImport", reflect.TypeOf((*MockInfraFacade)(nil).GetImport), ctx, proxyEndpoint, projectID, importID)
}

// ListBranches mocks base method.
func (m *MockInfraFacade) ListBranches(ctx context.Context, proxyEndpoint string) ([]v1.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranches", ctx, proxyEndpoint)
	ret0, _ := ret[0].([]v1.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBranches indicates an expected call of ListBranches.
func (mr *MockInfraFacadeMockRecorder) ListBranches(ctx, proxyEndpoint any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockInfraFacade)(nil).ListBranches), ctx, proxyEndpoint)
}

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

// Namespace indicates an expected call of Namespace.
func (mr *MockInfraFacadeMockRecorder) Namespace(projectID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Namespace", reflect.TypeOf((*MockInfraFacade)(nil).Namespace), projectID)
}

// UpdateBranch mocks base method.
func (m *MockInfraFacade) UpdateBranch(ctx context.Context, b *v1.Branch) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBranch", ctx, b)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateBranch indicates an expected call of UpdateBranch.
func (mr *MockInfraFacadeMockRecorder) UpdateBranch(ctx, b any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBranch", reflect.TypeOf((*MockInfraFacade)(nil).UpdateBranch), ctx, b)
}

// UpdateBranchStatus mocks base method.
func (m *MockInfraFacade) UpdateBranchStatus(ctx context.Context, b *v1.Branch) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBranchStatus", ctx, b)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateBranchStatus indicates an expected call of UpdateBranchStatus.
func (mr *MockInfraFacadeMockRecorder) UpdateBranchStatus(ctx, b any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBranchStatus", reflect.TypeOf((*MockInfraFacade)(nil).UpdateBranchStatus), ctx, b)
}

// UpdateExport mocks base method.
func (m *MockInfraFacade) UpdateExport(ctx context.Context, proxyEndpoint string, e *v1.Export) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateExport", ctx, proxyEndpoint, e)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateExport indicates an expected call of UpdateExport.
func (mr *MockInfraFacadeMockRecorder) UpdateExport(ctx, proxyEndpoint, e any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExport", reflect.TypeOf((*MockInfraFacade)(nil).UpdateExport), ctx, proxyEndpoint, e)
}