// Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/domain/repo/privatelink.go
//
// Generated by this command:
//
//	mockgen -source=./internal/domain/repo/privatelink.go -destination ./internal/domain/repo/mock_repo/mock_privatelink.go -package mock_repo
//

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

import (
	context "context"
	reflect "reflect"

	bizerr "github.com/tidbcloud/pkgv2/bizerr"
	constant "github.com/tidbcloud/serverless-service/internal/domain/constant"
	entity "github.com/tidbcloud/serverless-service/internal/domain/entity"
	gomock "go.uber.org/mock/gomock"
)

// MockPrivateLinkConnectionRepo is a mock of PrivateLinkConnectionRepo interface.
type MockPrivateLinkConnectionRepo struct {
	ctrl     *gomock.Controller
	recorder *MockPrivateLinkConnectionRepoMockRecorder
}

// MockPrivateLinkConnectionRepoMockRecorder is the mock recorder for MockPrivateLinkConnectionRepo.
type MockPrivateLinkConnectionRepoMockRecorder struct {
	mock *MockPrivateLinkConnectionRepo
}

// NewMockPrivateLinkConnectionRepo creates a new mock instance.
func NewMockPrivateLinkConnectionRepo(ctrl *gomock.Controller) *MockPrivateLinkConnectionRepo {
	mock := &MockPrivateLinkConnectionRepo{ctrl: ctrl}
	mock.recorder = &MockPrivateLinkConnectionRepoMockRecorder{mock}
	return mock
}

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

// CountByFilter mocks base method.
func (m *MockPrivateLinkConnectionRepo) CountByFilter(ctx context.Context, filter *entity.ListPrivateLinkConnectionFilter) (int64, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountByFilter", ctx, filter)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CountByFilter indicates an expected call of CountByFilter.
func (mr *MockPrivateLinkConnectionRepoMockRecorder) CountByFilter(ctx, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountByFilter", reflect.TypeOf((*MockPrivateLinkConnectionRepo)(nil).CountByFilter), ctx, filter)
}

// Create mocks base method.
func (m *MockPrivateLinkConnectionRepo) Create(ctx context.Context, plc *entity.PrivateLinkConnection) (*entity.PrivateLinkConnection, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, plc)
	ret0, _ := ret[0].(*entity.PrivateLinkConnection)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockPrivateLinkConnectionRepoMockRecorder) Create(ctx, plc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPrivateLinkConnectionRepo)(nil).Create), ctx, plc)
}

// DeleteById mocks base method.
func (m *MockPrivateLinkConnectionRepo) DeleteById(ctx context.Context, clusterId, id string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteById", ctx, clusterId, id)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteById indicates an expected call of DeleteById.
func (mr *MockPrivateLinkConnectionRepoMockRecorder) DeleteById(ctx, clusterId, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteById", reflect.TypeOf((*MockPrivateLinkConnectionRepo)(nil).DeleteById), ctx, clusterId, id)
}

// GetById mocks base method.
func (m *MockPrivateLinkConnectionRepo) GetById(ctx context.Context, clusterId, id string) (*entity.PrivateLinkConnection, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetById", ctx, clusterId, id)
	ret0, _ := ret[0].(*entity.PrivateLinkConnection)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetById indicates an expected call of GetById.
func (mr *MockPrivateLinkConnectionRepoMockRecorder) GetById(ctx, clusterId, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetById", reflect.TypeOf((*MockPrivateLinkConnectionRepo)(nil).GetById), ctx, clusterId, id)
}

// GetByID mocks base method.
func (m *MockPrivateLinkConnectionRepo) GetByID(ctx context.Context, id string) (*entity.PrivateLinkConnection, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*entity.PrivateLinkConnection)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetByID indicates an expected call of GetByID.
func (mr *MockPrivateLinkConnectionRepoMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockPrivateLinkConnectionRepo)(nil).GetByID), ctx, id)
}

// ListByFilter mocks base method.
func (m *MockPrivateLinkConnectionRepo) ListByFilter(ctx context.Context, filter *entity.ListPrivateLinkConnectionFilter) ([]*entity.PrivateLinkConnection, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByFilter", ctx, filter)
	ret0, _ := ret[0].([]*entity.PrivateLinkConnection)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListByFilter indicates an expected call of ListByFilter.
func (mr *MockPrivateLinkConnectionRepoMockRecorder) ListByFilter(ctx, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByFilter", reflect.TypeOf((*MockPrivateLinkConnectionRepo)(nil).ListByFilter), ctx, filter)
}

// Save mocks base method.
func (m *MockPrivateLinkConnectionRepo) Save(ctx context.Context, plc *entity.PrivateLinkConnection) (*entity.PrivateLinkConnection, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx, plc)
	ret0, _ := ret[0].(*entity.PrivateLinkConnection)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Save indicates an expected call of Save.
func (mr *MockPrivateLinkConnectionRepoMockRecorder) Save(ctx, plc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockPrivateLinkConnectionRepo)(nil).Save), ctx, plc)
}

// MockPrivateLinkConnectionLinkRepo is a mock of PrivateLinkConnectionLinkRepo interface.
type MockPrivateLinkConnectionLinkRepo struct {
	ctrl     *gomock.Controller
	recorder *MockPrivateLinkConnectionLinkRepoMockRecorder
}

// MockPrivateLinkConnectionLinkRepoMockRecorder is the mock recorder for MockPrivateLinkConnectionLinkRepo.
type MockPrivateLinkConnectionLinkRepoMockRecorder struct {
	mock *MockPrivateLinkConnectionLinkRepo
}

// NewMockPrivateLinkConnectionLinkRepo creates a new mock instance.
func NewMockPrivateLinkConnectionLinkRepo(ctrl *gomock.Controller) *MockPrivateLinkConnectionLinkRepo {
	mock := &MockPrivateLinkConnectionLinkRepo{ctrl: ctrl}
	mock.recorder = &MockPrivateLinkConnectionLinkRepoMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m *MockPrivateLinkConnectionLinkRepo) Create(ctx context.Context, link *entity.PrivateLinkConnectionLink) (*entity.PrivateLinkConnectionLink, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, link)
	ret0, _ := ret[0].(*entity.PrivateLinkConnectionLink)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockPrivateLinkConnectionLinkRepoMockRecorder) Create(ctx, link any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPrivateLinkConnectionLinkRepo)(nil).Create), ctx, link)
}

// Delete mocks base method.
func (m *MockPrivateLinkConnectionLinkRepo) Delete(ctx context.Context, clusterId, privateLinkConnectionID, bizID string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, clusterId, privateLinkConnectionID, bizID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockPrivateLinkConnectionLinkRepoMockRecorder) Delete(ctx, clusterId, privateLinkConnectionID, bizID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPrivateLinkConnectionLinkRepo)(nil).Delete), ctx, clusterId, privateLinkConnectionID, bizID)
}

// DeleteByPrivateLinkConnectionID mocks base method.
func (m *MockPrivateLinkConnectionLinkRepo) DeleteByPrivateLinkConnectionID(ctx context.Context, clusterId, privateLinkConnectionID string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteByPrivateLinkConnectionID", ctx, clusterId, privateLinkConnectionID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteByPrivateLinkConnectionID indicates an expected call of DeleteByPrivateLinkConnectionID.
func (mr *MockPrivateLinkConnectionLinkRepoMockRecorder) DeleteByPrivateLinkConnectionID(ctx, clusterId, privateLinkConnectionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByPrivateLinkConnectionID", reflect.TypeOf((*MockPrivateLinkConnectionLinkRepo)(nil).DeleteByPrivateLinkConnectionID), ctx, clusterId, privateLinkConnectionID)
}

// ListByPrivateLinkConnectionID mocks base method.
func (m *MockPrivateLinkConnectionLinkRepo) ListByPrivateLinkConnectionID(ctx context.Context, clusterId, privateLinkConnectionID string) ([]*entity.PrivateLinkConnectionLink, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByPrivateLinkConnectionID", ctx, clusterId, privateLinkConnectionID)
	ret0, _ := ret[0].([]*entity.PrivateLinkConnectionLink)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListByPrivateLinkConnectionID indicates an expected call of ListByPrivateLinkConnectionID.
func (mr *MockPrivateLinkConnectionLinkRepoMockRecorder) ListByPrivateLinkConnectionID(ctx, clusterId, privateLinkConnectionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByPrivateLinkConnectionID", reflect.TypeOf((*MockPrivateLinkConnectionLinkRepo)(nil).ListByPrivateLinkConnectionID), ctx, clusterId, privateLinkConnectionID)
}

// MockPLCAttachDomainRepo is a mock of PLCAttachDomainRepo interface.
type MockPLCAttachDomainRepo struct {
	ctrl     *gomock.Controller
	recorder *MockPLCAttachDomainRepoMockRecorder
}

// MockPLCAttachDomainRepoMockRecorder is the mock recorder for MockPLCAttachDomainRepo.
type MockPLCAttachDomainRepoMockRecorder struct {
	mock *MockPLCAttachDomainRepo
}

// NewMockPLCAttachDomainRepo creates a new mock instance.
func NewMockPLCAttachDomainRepo(ctrl *gomock.Controller) *MockPLCAttachDomainRepo {
	mock := &MockPLCAttachDomainRepo{ctrl: ctrl}
	mock.recorder = &MockPLCAttachDomainRepoMockRecorder{mock}
	return mock
}

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

// CheckHostedZone mocks base method.
func (m *MockPLCAttachDomainRepo) CheckHostedZone(ctx context.Context, hostedZone, unique_id string) (bool, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckHostedZone", ctx, hostedZone, unique_id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CheckHostedZone indicates an expected call of CheckHostedZone.
func (mr *MockPLCAttachDomainRepoMockRecorder) CheckHostedZone(ctx, hostedZone, unique_id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckHostedZone", reflect.TypeOf((*MockPLCAttachDomainRepo)(nil).CheckHostedZone), ctx, hostedZone, unique_id)
}

// CountByPLC mocks base method.
func (m *MockPLCAttachDomainRepo) CountByPLC(ctx context.Context, clusterID, plcID string) (int64, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountByPLC", ctx, clusterID, plcID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// CountByPLC indicates an expected call of CountByPLC.
func (mr *MockPLCAttachDomainRepoMockRecorder) CountByPLC(ctx, clusterID, plcID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountByPLC", reflect.TypeOf((*MockPLCAttachDomainRepo)(nil).CountByPLC), ctx, clusterID, plcID)
}

// Create mocks base method.
func (m *MockPLCAttachDomainRepo) Create(ctx context.Context, d *entity.PLCAttachDomain) (*entity.PLCAttachDomain, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, d)
	ret0, _ := ret[0].(*entity.PLCAttachDomain)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockPLCAttachDomainRepoMockRecorder) Create(ctx, d any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPLCAttachDomainRepo)(nil).Create), ctx, d)
}

// DeleteByID mocks base method.
func (m *MockPLCAttachDomainRepo) DeleteByID(ctx context.Context, clusterID, plcID, attachDomainID string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteByID", ctx, clusterID, plcID, attachDomainID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteByID indicates an expected call of DeleteByID.
func (mr *MockPLCAttachDomainRepoMockRecorder) DeleteByID(ctx, clusterID, plcID, attachDomainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByID", reflect.TypeOf((*MockPLCAttachDomainRepo)(nil).DeleteByID), ctx, clusterID, plcID, attachDomainID)
}

// Get mocks base method.
func (m *MockPLCAttachDomainRepo) Get(ctx context.Context, clusterID, plcID, attachDomainID string) (*entity.PLCAttachDomain, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, clusterID, plcID, attachDomainID)
	ret0, _ := ret[0].(*entity.PLCAttachDomain)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockPLCAttachDomainRepoMockRecorder) Get(ctx, clusterID, plcID, attachDomainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPLCAttachDomainRepo)(nil).Get), ctx, clusterID, plcID, attachDomainID)
}

// ListByFilter mocks base method.
func (m *MockPLCAttachDomainRepo) ListByFilter(ctx context.Context, filter entity.ListPLCAttachDomainsFilter) ([]*entity.PLCAttachDomain, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByFilter", ctx, filter)
	ret0, _ := ret[0].([]*entity.PLCAttachDomain)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListByFilter indicates an expected call of ListByFilter.
func (mr *MockPLCAttachDomainRepoMockRecorder) ListByFilter(ctx, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByFilter", reflect.TypeOf((*MockPLCAttachDomainRepo)(nil).ListByFilter), ctx, filter)
}

// Save mocks base method.
func (m *MockPLCAttachDomainRepo) Save(ctx context.Context, d *entity.PLCAttachDomain) (*entity.PLCAttachDomain, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx, d)
	ret0, _ := ret[0].(*entity.PLCAttachDomain)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// Save indicates an expected call of Save.
func (mr *MockPLCAttachDomainRepoMockRecorder) Save(ctx, d any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockPLCAttachDomainRepo)(nil).Save), ctx, d)
}

// MockPLCDomainRecordRepo is a mock of PLCDomainRecordRepo interface.
type MockPLCDomainRecordRepo struct {
	ctrl     *gomock.Controller
	recorder *MockPLCDomainRecordRepoMockRecorder
}

// MockPLCDomainRecordRepoMockRecorder is the mock recorder for MockPLCDomainRecordRepo.
type MockPLCDomainRecordRepoMockRecorder struct {
	mock *MockPLCDomainRecordRepo
}

// NewMockPLCDomainRecordRepo creates a new mock instance.
func NewMockPLCDomainRecordRepo(ctrl *gomock.Controller) *MockPLCDomainRecordRepo {
	mock := &MockPLCDomainRecordRepo{ctrl: ctrl}
	mock.recorder = &MockPLCDomainRecordRepoMockRecorder{mock}
	return mock
}

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

// ActiveByAttachDomainID mocks base method.
func (m *MockPLCDomainRecordRepo) ActiveByAttachDomainID(ctx context.Context, clusterID, plcID, attachDomainID, awsRoute53CreateChangeID string, aliDNSRecordID int64) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActiveByAttachDomainID", ctx, clusterID, plcID, attachDomainID, awsRoute53CreateChangeID, aliDNSRecordID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// ActiveByAttachDomainID indicates an expected call of ActiveByAttachDomainID.
func (mr *MockPLCDomainRecordRepoMockRecorder) ActiveByAttachDomainID(ctx, clusterID, plcID, attachDomainID, awsRoute53CreateChangeID, aliDNSRecordID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActiveByAttachDomainID", reflect.TypeOf((*MockPLCDomainRecordRepo)(nil).ActiveByAttachDomainID), ctx, clusterID, plcID, attachDomainID, awsRoute53CreateChangeID, aliDNSRecordID)
}

// BatchInsert mocks base method.
func (m *MockPLCDomainRecordRepo) BatchInsert(ctx context.Context, records []*entity.PLCDomainRecord) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchInsert", ctx, records)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// BatchInsert indicates an expected call of BatchInsert.
func (mr *MockPLCDomainRecordRepoMockRecorder) BatchInsert(ctx, records any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchInsert", reflect.TypeOf((*MockPLCDomainRecordRepo)(nil).BatchInsert), ctx, records)
}

// ListByFilter mocks base method.
func (m *MockPLCDomainRecordRepo) ListByFilter(ctx context.Context, filter *entity.ListPLCDomainRecordsFilter) ([]*entity.PLCDomainRecord, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByFilter", ctx, filter)
	ret0, _ := ret[0].([]*entity.PLCDomainRecord)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListByFilter indicates an expected call of ListByFilter.
func (mr *MockPLCDomainRecordRepoMockRecorder) ListByFilter(ctx, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByFilter", reflect.TypeOf((*MockPLCDomainRecordRepo)(nil).ListByFilter), ctx, filter)
}

// SoftDeleteByID mocks base method.
func (m *MockPLCDomainRecordRepo) SoftDeleteByID(ctx context.Context, clusterID, plcID, attachDomainID string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SoftDeleteByID", ctx, clusterID, plcID, attachDomainID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// SoftDeleteByID indicates an expected call of SoftDeleteByID.
func (mr *MockPLCDomainRecordRepoMockRecorder) SoftDeleteByID(ctx, clusterID, plcID, attachDomainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SoftDeleteByID", reflect.TypeOf((*MockPLCDomainRecordRepo)(nil).SoftDeleteByID), ctx, clusterID, plcID, attachDomainID)
}

// SoftDeleteByPLC mocks base method.
func (m *MockPLCDomainRecordRepo) SoftDeleteByPLC(ctx context.Context, clusterID, plcID string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SoftDeleteByPLC", ctx, clusterID, plcID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// SoftDeleteByPLC indicates an expected call of SoftDeleteByPLC.
func (mr *MockPLCDomainRecordRepoMockRecorder) SoftDeleteByPLC(ctx, clusterID, plcID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SoftDeleteByPLC", reflect.TypeOf((*MockPLCDomainRecordRepo)(nil).SoftDeleteByPLC), ctx, clusterID, plcID)
}

// UpdateByID mocks base method.
func (m *MockPLCDomainRecordRepo) UpdateByID(ctx context.Context, clusterID, plcID, attachDomainID, awsRoute53DeleteChangeID string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateByID", ctx, clusterID, plcID, attachDomainID, awsRoute53DeleteChangeID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateByID indicates an expected call of UpdateByID.
func (mr *MockPLCDomainRecordRepoMockRecorder) UpdateByID(ctx, clusterID, plcID, attachDomainID, awsRoute53DeleteChangeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateByID", reflect.TypeOf((*MockPLCDomainRecordRepo)(nil).UpdateByID), ctx, clusterID, plcID, attachDomainID, awsRoute53DeleteChangeID)
}

// UpdateStateByAttachDomainID mocks base method.
func (m *MockPLCDomainRecordRepo) UpdateStateByAttachDomainID(ctx context.Context, clusterID, plcID, attachDomainID string, state constant.PLCDomainRecordState, message string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateStateByAttachDomainID", ctx, clusterID, plcID, attachDomainID, state, message)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// UpdateStateByAttachDomainID indicates an expected call of UpdateStateByAttachDomainID.
func (mr *MockPLCDomainRecordRepoMockRecorder) UpdateStateByAttachDomainID(ctx, clusterID, plcID, attachDomainID, state, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStateByAttachDomainID", reflect.TypeOf((*MockPLCDomainRecordRepo)(nil).UpdateStateByAttachDomainID), ctx, clusterID, plcID, attachDomainID, state, message)
}