// Code generated by MockGen. DO NOT EDIT.
// Source: registry.go
//
// Generated by this command:
//
//	mockgen -source registry.go -destination registry_mock.go -package agentsidecar
//

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

import (
	context "context"
	reflect "reflect"

	apiproxyv1 "github.com/tidbcloud/aisupport/packages/sdk-go/contracts/api/agent-sidecar/apiproxy/v1"
	projectv1 "github.com/tidbcloud/aisupport/packages/sdk-go/contracts/api/agent-sidecar/project/v1"
	secretstorev1 "github.com/tidbcloud/aisupport/packages/sdk-go/contracts/api/agent-sidecar/secretstore/v1"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockProjectClient is a mock of ProjectClient interface.
type MockProjectClient struct {
	ctrl     *gomock.Controller
	recorder *MockProjectClientMockRecorder
	isgomock struct{}
}

// MockProjectClientMockRecorder is the mock recorder for MockProjectClient.
type MockProjectClientMockRecorder struct {
	mock *MockProjectClient
}

// NewMockProjectClient creates a new mock instance.
func NewMockProjectClient(ctrl *gomock.Controller) *MockProjectClient {
	mock := &MockProjectClient{ctrl: ctrl}
	mock.recorder = &MockProjectClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockAPIProxyClient is a mock of APIProxyClient interface.
type MockAPIProxyClient struct {
	ctrl     *gomock.Controller
	recorder *MockAPIProxyClientMockRecorder
	isgomock struct{}
}

// MockAPIProxyClientMockRecorder is the mock recorder for MockAPIProxyClient.
type MockAPIProxyClientMockRecorder struct {
	mock *MockAPIProxyClient
}

// NewMockAPIProxyClient creates a new mock instance.
func NewMockAPIProxyClient(ctrl *gomock.Controller) *MockAPIProxyClient {
	mock := &MockAPIProxyClient{ctrl: ctrl}
	mock.recorder = &MockAPIProxyClientMockRecorder{mock}
	return mock
}

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

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

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

// MockSecretStoreClient is a mock of SecretStoreClient interface.
type MockSecretStoreClient struct {
	ctrl     *gomock.Controller
	recorder *MockSecretStoreClientMockRecorder
	isgomock struct{}
}

// MockSecretStoreClientMockRecorder is the mock recorder for MockSecretStoreClient.
type MockSecretStoreClientMockRecorder struct {
	mock *MockSecretStoreClient
}

// NewMockSecretStoreClient creates a new mock instance.
func NewMockSecretStoreClient(ctrl *gomock.Controller) *MockSecretStoreClient {
	mock := &MockSecretStoreClient{ctrl: ctrl}
	mock.recorder = &MockSecretStoreClientMockRecorder{mock}
	return mock
}

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

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

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