//                           _       _
// __      _____  __ ___   ___  __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
//  Copyright © 2016 - 2026 Weaviate B.V. All rights reserved.
//
//  CONTACT: hello@weaviate.io
//

// Code generated by mockery v2.53.5. DO NOT EDIT.

package copier

import (
	context "context"

	grpc "google.golang.org/grpc"

	mock "github.com/stretchr/testify/mock"

	protocol "github.com/weaviate/weaviate/adapters/handlers/rest/clusterapi/grpc/generated/protocol"
)

// MockFileReplicationServiceClient is an autogenerated mock type for the FileReplicationServiceClient type
type MockFileReplicationServiceClient struct {
	mock.Mock
}

type MockFileReplicationServiceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFileReplicationServiceClient) EXPECT() *MockFileReplicationServiceClient_Expecter {
	return &MockFileReplicationServiceClient_Expecter{mock: &_m.Mock}
}

// GetFile provides a mock function with given fields: ctx, in, opts
func (_m *MockFileReplicationServiceClient) GetFile(ctx context.Context, in *protocol.GetFileRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[protocol.FileChunk], error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetFile")
	}

	var r0 grpc.ServerStreamingClient[protocol.FileChunk]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.GetFileRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[protocol.FileChunk], error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.GetFileRequest, ...grpc.CallOption) grpc.ServerStreamingClient[protocol.FileChunk]); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(grpc.ServerStreamingClient[protocol.FileChunk])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *protocol.GetFileRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockFileReplicationServiceClient_GetFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFile'
type MockFileReplicationServiceClient_GetFile_Call struct {
	*mock.Call
}

// GetFile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *protocol.GetFileRequest
//   - opts ...grpc.CallOption
func (_e *MockFileReplicationServiceClient_Expecter) GetFile(ctx interface{}, in interface{}, opts ...interface{}) *MockFileReplicationServiceClient_GetFile_Call {
	return &MockFileReplicationServiceClient_GetFile_Call{Call: _e.mock.On("GetFile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockFileReplicationServiceClient_GetFile_Call) Run(run func(ctx context.Context, in *protocol.GetFileRequest, opts ...grpc.CallOption)) *MockFileReplicationServiceClient_GetFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*protocol.GetFileRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockFileReplicationServiceClient_GetFile_Call) Return(_a0 grpc.ServerStreamingClient[protocol.FileChunk], _a1 error) *MockFileReplicationServiceClient_GetFile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockFileReplicationServiceClient_GetFile_Call) RunAndReturn(run func(context.Context, *protocol.GetFileRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[protocol.FileChunk], error)) *MockFileReplicationServiceClient_GetFile_Call {
	_c.Call.Return(run)
	return _c
}

// GetFileMetadata provides a mock function with given fields: ctx, in, opts
func (_m *MockFileReplicationServiceClient) GetFileMetadata(ctx context.Context, in *protocol.GetFileMetadataRequest, opts ...grpc.CallOption) (*protocol.FileMetadata, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetFileMetadata")
	}

	var r0 *protocol.FileMetadata
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.GetFileMetadataRequest, ...grpc.CallOption) (*protocol.FileMetadata, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.GetFileMetadataRequest, ...grpc.CallOption) *protocol.FileMetadata); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*protocol.FileMetadata)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *protocol.GetFileMetadataRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockFileReplicationServiceClient_GetFileMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFileMetadata'
type MockFileReplicationServiceClient_GetFileMetadata_Call struct {
	*mock.Call
}

// GetFileMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - in *protocol.GetFileMetadataRequest
//   - opts ...grpc.CallOption
func (_e *MockFileReplicationServiceClient_Expecter) GetFileMetadata(ctx interface{}, in interface{}, opts ...interface{}) *MockFileReplicationServiceClient_GetFileMetadata_Call {
	return &MockFileReplicationServiceClient_GetFileMetadata_Call{Call: _e.mock.On("GetFileMetadata",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockFileReplicationServiceClient_GetFileMetadata_Call) Run(run func(ctx context.Context, in *protocol.GetFileMetadataRequest, opts ...grpc.CallOption)) *MockFileReplicationServiceClient_GetFileMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*protocol.GetFileMetadataRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockFileReplicationServiceClient_GetFileMetadata_Call) Return(_a0 *protocol.FileMetadata, _a1 error) *MockFileReplicationServiceClient_GetFileMetadata_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockFileReplicationServiceClient_GetFileMetadata_Call) RunAndReturn(run func(context.Context, *protocol.GetFileMetadataRequest, ...grpc.CallOption) (*protocol.FileMetadata, error)) *MockFileReplicationServiceClient_GetFileMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// ListFiles provides a mock function with given fields: ctx, in, opts
func (_m *MockFileReplicationServiceClient) ListFiles(ctx context.Context, in *protocol.ListFilesRequest, opts ...grpc.CallOption) (*protocol.ListFilesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListFiles")
	}

	var r0 *protocol.ListFilesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ListFilesRequest, ...grpc.CallOption) (*protocol.ListFilesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ListFilesRequest, ...grpc.CallOption) *protocol.ListFilesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*protocol.ListFilesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *protocol.ListFilesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockFileReplicationServiceClient_ListFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFiles'
type MockFileReplicationServiceClient_ListFiles_Call struct {
	*mock.Call
}

// ListFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - in *protocol.ListFilesRequest
//   - opts ...grpc.CallOption
func (_e *MockFileReplicationServiceClient_Expecter) ListFiles(ctx interface{}, in interface{}, opts ...interface{}) *MockFileReplicationServiceClient_ListFiles_Call {
	return &MockFileReplicationServiceClient_ListFiles_Call{Call: _e.mock.On("ListFiles",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockFileReplicationServiceClient_ListFiles_Call) Run(run func(ctx context.Context, in *protocol.ListFilesRequest, opts ...grpc.CallOption)) *MockFileReplicationServiceClient_ListFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*protocol.ListFilesRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockFileReplicationServiceClient_ListFiles_Call) Return(_a0 *protocol.ListFilesResponse, _a1 error) *MockFileReplicationServiceClient_ListFiles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockFileReplicationServiceClient_ListFiles_Call) RunAndReturn(run func(context.Context, *protocol.ListFilesRequest, ...grpc.CallOption) (*protocol.ListFilesResponse, error)) *MockFileReplicationServiceClient_ListFiles_Call {
	_c.Call.Return(run)
	return _c
}

// PauseFileActivity provides a mock function with given fields: ctx, in, opts
func (_m *MockFileReplicationServiceClient) PauseFileActivity(ctx context.Context, in *protocol.PauseFileActivityRequest, opts ...grpc.CallOption) (*protocol.PauseFileActivityResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PauseFileActivity")
	}

	var r0 *protocol.PauseFileActivityResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.PauseFileActivityRequest, ...grpc.CallOption) (*protocol.PauseFileActivityResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.PauseFileActivityRequest, ...grpc.CallOption) *protocol.PauseFileActivityResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*protocol.PauseFileActivityResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *protocol.PauseFileActivityRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockFileReplicationServiceClient_PauseFileActivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PauseFileActivity'
type MockFileReplicationServiceClient_PauseFileActivity_Call struct {
	*mock.Call
}

// PauseFileActivity is a helper method to define mock.On call
//   - ctx context.Context
//   - in *protocol.PauseFileActivityRequest
//   - opts ...grpc.CallOption
func (_e *MockFileReplicationServiceClient_Expecter) PauseFileActivity(ctx interface{}, in interface{}, opts ...interface{}) *MockFileReplicationServiceClient_PauseFileActivity_Call {
	return &MockFileReplicationServiceClient_PauseFileActivity_Call{Call: _e.mock.On("PauseFileActivity",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockFileReplicationServiceClient_PauseFileActivity_Call) Run(run func(ctx context.Context, in *protocol.PauseFileActivityRequest, opts ...grpc.CallOption)) *MockFileReplicationServiceClient_PauseFileActivity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*protocol.PauseFileActivityRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockFileReplicationServiceClient_PauseFileActivity_Call) Return(_a0 *protocol.PauseFileActivityResponse, _a1 error) *MockFileReplicationServiceClient_PauseFileActivity_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockFileReplicationServiceClient_PauseFileActivity_Call) RunAndReturn(run func(context.Context, *protocol.PauseFileActivityRequest, ...grpc.CallOption) (*protocol.PauseFileActivityResponse, error)) *MockFileReplicationServiceClient_PauseFileActivity_Call {
	_c.Call.Return(run)
	return _c
}

// ResumeFileActivity provides a mock function with given fields: ctx, in, opts
func (_m *MockFileReplicationServiceClient) ResumeFileActivity(ctx context.Context, in *protocol.ResumeFileActivityRequest, opts ...grpc.CallOption) (*protocol.ResumeFileActivityResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ResumeFileActivity")
	}

	var r0 *protocol.ResumeFileActivityResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ResumeFileActivityRequest, ...grpc.CallOption) (*protocol.ResumeFileActivityResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *protocol.ResumeFileActivityRequest, ...grpc.CallOption) *protocol.ResumeFileActivityResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*protocol.ResumeFileActivityResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *protocol.ResumeFileActivityRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockFileReplicationServiceClient_ResumeFileActivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumeFileActivity'
type MockFileReplicationServiceClient_ResumeFileActivity_Call struct {
	*mock.Call
}

// ResumeFileActivity is a helper method to define mock.On call
//   - ctx context.Context
//   - in *protocol.ResumeFileActivityRequest
//   - opts ...grpc.CallOption
func (_e *MockFileReplicationServiceClient_Expecter) ResumeFileActivity(ctx interface{}, in interface{}, opts ...interface{}) *MockFileReplicationServiceClient_ResumeFileActivity_Call {
	return &MockFileReplicationServiceClient_ResumeFileActivity_Call{Call: _e.mock.On("ResumeFileActivity",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *MockFileReplicationServiceClient_ResumeFileActivity_Call) Run(run func(ctx context.Context, in *protocol.ResumeFileActivityRequest, opts ...grpc.CallOption)) *MockFileReplicationServiceClient_ResumeFileActivity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*protocol.ResumeFileActivityRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockFileReplicationServiceClient_ResumeFileActivity_Call) Return(_a0 *protocol.ResumeFileActivityResponse, _a1 error) *MockFileReplicationServiceClient_ResumeFileActivity_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockFileReplicationServiceClient_ResumeFileActivity_Call) RunAndReturn(run func(context.Context, *protocol.ResumeFileActivityRequest, ...grpc.CallOption) (*protocol.ResumeFileActivityResponse, error)) *MockFileReplicationServiceClient_ResumeFileActivity_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockFileReplicationServiceClient creates a new instance of MockFileReplicationServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockFileReplicationServiceClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFileReplicationServiceClient {
	mock := &MockFileReplicationServiceClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
