// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v3.6.1
// source: hiddifyrpc/hiddify.proto

package hiddifyrpc

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	Hello_SayHello_FullMethodName       = "/hiddifyrpc.Hello/SayHello"
	Hello_SayHelloStream_FullMethodName = "/hiddifyrpc.Hello/SayHelloStream"
)

// HelloClient is the client API for Hello service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type HelloClient interface {
	SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloResponse, error)
	SayHelloStream(ctx context.Context, opts ...grpc.CallOption) (Hello_SayHelloStreamClient, error)
}

type helloClient struct {
	cc grpc.ClientConnInterface
}

func NewHelloClient(cc grpc.ClientConnInterface) HelloClient {
	return &helloClient{cc}
}

func (c *helloClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloResponse, error) {
	out := new(HelloResponse)
	err := c.cc.Invoke(ctx, Hello_SayHello_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *helloClient) SayHelloStream(ctx context.Context, opts ...grpc.CallOption) (Hello_SayHelloStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &Hello_ServiceDesc.Streams[0], Hello_SayHelloStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &helloSayHelloStreamClient{stream}
	return x, nil
}

type Hello_SayHelloStreamClient interface {
	Send(*HelloRequest) error
	Recv() (*HelloResponse, error)
	grpc.ClientStream
}

type helloSayHelloStreamClient struct {
	grpc.ClientStream
}

func (x *helloSayHelloStreamClient) Send(m *HelloRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *helloSayHelloStreamClient) Recv() (*HelloResponse, error) {
	m := new(HelloResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// HelloServer is the server API for Hello service.
// All implementations must embed UnimplementedHelloServer
// for forward compatibility
type HelloServer interface {
	SayHello(context.Context, *HelloRequest) (*HelloResponse, error)
	SayHelloStream(Hello_SayHelloStreamServer) error
	mustEmbedUnimplementedHelloServer()
}

// UnimplementedHelloServer must be embedded to have forward compatible implementations.
type UnimplementedHelloServer struct {
}

func (UnimplementedHelloServer) SayHello(context.Context, *HelloRequest) (*HelloResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
}
func (UnimplementedHelloServer) SayHelloStream(Hello_SayHelloStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method SayHelloStream not implemented")
}
func (UnimplementedHelloServer) mustEmbedUnimplementedHelloServer() {}

// UnsafeHelloServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to HelloServer will
// result in compilation errors.
type UnsafeHelloServer interface {
	mustEmbedUnimplementedHelloServer()
}

func RegisterHelloServer(s grpc.ServiceRegistrar, srv HelloServer) {
	s.RegisterService(&Hello_ServiceDesc, srv)
}

func _Hello_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HelloRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HelloServer).SayHello(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Hello_SayHello_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HelloServer).SayHello(ctx, req.(*HelloRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Hello_SayHelloStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(HelloServer).SayHelloStream(&helloSayHelloStreamServer{stream})
}

type Hello_SayHelloStreamServer interface {
	Send(*HelloResponse) error
	Recv() (*HelloRequest, error)
	grpc.ServerStream
}

type helloSayHelloStreamServer struct {
	grpc.ServerStream
}

func (x *helloSayHelloStreamServer) Send(m *HelloResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *helloSayHelloStreamServer) Recv() (*HelloRequest, error) {
	m := new(HelloRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Hello_ServiceDesc is the grpc.ServiceDesc for Hello service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Hello_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hiddifyrpc.Hello",
	HandlerType: (*HelloServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SayHello",
			Handler:    _Hello_SayHello_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SayHelloStream",
			Handler:       _Hello_SayHelloStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "hiddifyrpc/hiddify.proto",
}

const (
	Core_Start_FullMethodName                 = "/hiddifyrpc.Core/Start"
	Core_CoreInfoListener_FullMethodName      = "/hiddifyrpc.Core/CoreInfoListener"
	Core_OutboundsInfo_FullMethodName         = "/hiddifyrpc.Core/OutboundsInfo"
	Core_MainOutboundsInfo_FullMethodName     = "/hiddifyrpc.Core/MainOutboundsInfo"
	Core_GetSystemInfo_FullMethodName         = "/hiddifyrpc.Core/GetSystemInfo"
	Core_Setup_FullMethodName                 = "/hiddifyrpc.Core/Setup"
	Core_Parse_FullMethodName                 = "/hiddifyrpc.Core/Parse"
	Core_ChangeConfigOptions_FullMethodName   = "/hiddifyrpc.Core/ChangeConfigOptions"
	Core_StartService_FullMethodName          = "/hiddifyrpc.Core/StartService"
	Core_Stop_FullMethodName                  = "/hiddifyrpc.Core/Stop"
	Core_Restart_FullMethodName               = "/hiddifyrpc.Core/Restart"
	Core_SelectOutbound_FullMethodName        = "/hiddifyrpc.Core/SelectOutbound"
	Core_UrlTest_FullMethodName               = "/hiddifyrpc.Core/UrlTest"
	Core_GenerateWarpConfig_FullMethodName    = "/hiddifyrpc.Core/GenerateWarpConfig"
	Core_GetSystemProxyStatus_FullMethodName  = "/hiddifyrpc.Core/GetSystemProxyStatus"
	Core_SetSystemProxyEnabled_FullMethodName = "/hiddifyrpc.Core/SetSystemProxyEnabled"
	Core_LogListener_FullMethodName           = "/hiddifyrpc.Core/LogListener"
)

// CoreClient is the client API for Core service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type CoreClient interface {
	Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*CoreInfoResponse, error)
	CoreInfoListener(ctx context.Context, opts ...grpc.CallOption) (Core_CoreInfoListenerClient, error)
	OutboundsInfo(ctx context.Context, opts ...grpc.CallOption) (Core_OutboundsInfoClient, error)
	MainOutboundsInfo(ctx context.Context, opts ...grpc.CallOption) (Core_MainOutboundsInfoClient, error)
	GetSystemInfo(ctx context.Context, opts ...grpc.CallOption) (Core_GetSystemInfoClient, error)
	Setup(ctx context.Context, in *SetupRequest, opts ...grpc.CallOption) (*Response, error)
	Parse(ctx context.Context, in *ParseRequest, opts ...grpc.CallOption) (*ParseResponse, error)
	ChangeConfigOptions(ctx context.Context, in *ChangeConfigOptionsRequest, opts ...grpc.CallOption) (*CoreInfoResponse, error)
	//rpc GenerateConfig (GenerateConfigRequest) returns (GenerateConfigResponse);
	StartService(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*CoreInfoResponse, error)
	Stop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*CoreInfoResponse, error)
	Restart(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*CoreInfoResponse, error)
	SelectOutbound(ctx context.Context, in *SelectOutboundRequest, opts ...grpc.CallOption) (*Response, error)
	UrlTest(ctx context.Context, in *UrlTestRequest, opts ...grpc.CallOption) (*Response, error)
	GenerateWarpConfig(ctx context.Context, in *GenerateWarpConfigRequest, opts ...grpc.CallOption) (*WarpGenerationResponse, error)
	GetSystemProxyStatus(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SystemProxyStatus, error)
	SetSystemProxyEnabled(ctx context.Context, in *SetSystemProxyEnabledRequest, opts ...grpc.CallOption) (*Response, error)
	LogListener(ctx context.Context, opts ...grpc.CallOption) (Core_LogListenerClient, error)
}

type coreClient struct {
	cc grpc.ClientConnInterface
}

func NewCoreClient(cc grpc.ClientConnInterface) CoreClient {
	return &coreClient{cc}
}

func (c *coreClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*CoreInfoResponse, error) {
	out := new(CoreInfoResponse)
	err := c.cc.Invoke(ctx, Core_Start_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) CoreInfoListener(ctx context.Context, opts ...grpc.CallOption) (Core_CoreInfoListenerClient, error) {
	stream, err := c.cc.NewStream(ctx, &Core_ServiceDesc.Streams[0], Core_CoreInfoListener_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &coreCoreInfoListenerClient{stream}
	return x, nil
}

type Core_CoreInfoListenerClient interface {
	Send(*StopRequest) error
	Recv() (*CoreInfoResponse, error)
	grpc.ClientStream
}

type coreCoreInfoListenerClient struct {
	grpc.ClientStream
}

func (x *coreCoreInfoListenerClient) Send(m *StopRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *coreCoreInfoListenerClient) Recv() (*CoreInfoResponse, error) {
	m := new(CoreInfoResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *coreClient) OutboundsInfo(ctx context.Context, opts ...grpc.CallOption) (Core_OutboundsInfoClient, error) {
	stream, err := c.cc.NewStream(ctx, &Core_ServiceDesc.Streams[1], Core_OutboundsInfo_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &coreOutboundsInfoClient{stream}
	return x, nil
}

type Core_OutboundsInfoClient interface {
	Send(*StopRequest) error
	Recv() (*OutboundGroupList, error)
	grpc.ClientStream
}

type coreOutboundsInfoClient struct {
	grpc.ClientStream
}

func (x *coreOutboundsInfoClient) Send(m *StopRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *coreOutboundsInfoClient) Recv() (*OutboundGroupList, error) {
	m := new(OutboundGroupList)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *coreClient) MainOutboundsInfo(ctx context.Context, opts ...grpc.CallOption) (Core_MainOutboundsInfoClient, error) {
	stream, err := c.cc.NewStream(ctx, &Core_ServiceDesc.Streams[2], Core_MainOutboundsInfo_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &coreMainOutboundsInfoClient{stream}
	return x, nil
}

type Core_MainOutboundsInfoClient interface {
	Send(*StopRequest) error
	Recv() (*OutboundGroupList, error)
	grpc.ClientStream
}

type coreMainOutboundsInfoClient struct {
	grpc.ClientStream
}

func (x *coreMainOutboundsInfoClient) Send(m *StopRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *coreMainOutboundsInfoClient) Recv() (*OutboundGroupList, error) {
	m := new(OutboundGroupList)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *coreClient) GetSystemInfo(ctx context.Context, opts ...grpc.CallOption) (Core_GetSystemInfoClient, error) {
	stream, err := c.cc.NewStream(ctx, &Core_ServiceDesc.Streams[3], Core_GetSystemInfo_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &coreGetSystemInfoClient{stream}
	return x, nil
}

type Core_GetSystemInfoClient interface {
	Send(*StopRequest) error
	Recv() (*SystemInfo, error)
	grpc.ClientStream
}

type coreGetSystemInfoClient struct {
	grpc.ClientStream
}

func (x *coreGetSystemInfoClient) Send(m *StopRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *coreGetSystemInfoClient) Recv() (*SystemInfo, error) {
	m := new(SystemInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *coreClient) Setup(ctx context.Context, in *SetupRequest, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, Core_Setup_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) Parse(ctx context.Context, in *ParseRequest, opts ...grpc.CallOption) (*ParseResponse, error) {
	out := new(ParseResponse)
	err := c.cc.Invoke(ctx, Core_Parse_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) ChangeConfigOptions(ctx context.Context, in *ChangeConfigOptionsRequest, opts ...grpc.CallOption) (*CoreInfoResponse, error) {
	out := new(CoreInfoResponse)
	err := c.cc.Invoke(ctx, Core_ChangeConfigOptions_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) StartService(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*CoreInfoResponse, error) {
	out := new(CoreInfoResponse)
	err := c.cc.Invoke(ctx, Core_StartService_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) Stop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*CoreInfoResponse, error) {
	out := new(CoreInfoResponse)
	err := c.cc.Invoke(ctx, Core_Stop_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) Restart(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*CoreInfoResponse, error) {
	out := new(CoreInfoResponse)
	err := c.cc.Invoke(ctx, Core_Restart_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) SelectOutbound(ctx context.Context, in *SelectOutboundRequest, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, Core_SelectOutbound_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) UrlTest(ctx context.Context, in *UrlTestRequest, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, Core_UrlTest_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) GenerateWarpConfig(ctx context.Context, in *GenerateWarpConfigRequest, opts ...grpc.CallOption) (*WarpGenerationResponse, error) {
	out := new(WarpGenerationResponse)
	err := c.cc.Invoke(ctx, Core_GenerateWarpConfig_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) GetSystemProxyStatus(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SystemProxyStatus, error) {
	out := new(SystemProxyStatus)
	err := c.cc.Invoke(ctx, Core_GetSystemProxyStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) SetSystemProxyEnabled(ctx context.Context, in *SetSystemProxyEnabledRequest, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, Core_SetSystemProxyEnabled_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *coreClient) LogListener(ctx context.Context, opts ...grpc.CallOption) (Core_LogListenerClient, error) {
	stream, err := c.cc.NewStream(ctx, &Core_ServiceDesc.Streams[4], Core_LogListener_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &coreLogListenerClient{stream}
	return x, nil
}

type Core_LogListenerClient interface {
	Send(*StopRequest) error
	Recv() (*LogMessage, error)
	grpc.ClientStream
}

type coreLogListenerClient struct {
	grpc.ClientStream
}

func (x *coreLogListenerClient) Send(m *StopRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *coreLogListenerClient) Recv() (*LogMessage, error) {
	m := new(LogMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// CoreServer is the server API for Core service.
// All implementations must embed UnimplementedCoreServer
// for forward compatibility
type CoreServer interface {
	Start(context.Context, *StartRequest) (*CoreInfoResponse, error)
	CoreInfoListener(Core_CoreInfoListenerServer) error
	OutboundsInfo(Core_OutboundsInfoServer) error
	MainOutboundsInfo(Core_MainOutboundsInfoServer) error
	GetSystemInfo(Core_GetSystemInfoServer) error
	Setup(context.Context, *SetupRequest) (*Response, error)
	Parse(context.Context, *ParseRequest) (*ParseResponse, error)
	ChangeConfigOptions(context.Context, *ChangeConfigOptionsRequest) (*CoreInfoResponse, error)
	//rpc GenerateConfig (GenerateConfigRequest) returns (GenerateConfigResponse);
	StartService(context.Context, *StartRequest) (*CoreInfoResponse, error)
	Stop(context.Context, *Empty) (*CoreInfoResponse, error)
	Restart(context.Context, *StartRequest) (*CoreInfoResponse, error)
	SelectOutbound(context.Context, *SelectOutboundRequest) (*Response, error)
	UrlTest(context.Context, *UrlTestRequest) (*Response, error)
	GenerateWarpConfig(context.Context, *GenerateWarpConfigRequest) (*WarpGenerationResponse, error)
	GetSystemProxyStatus(context.Context, *Empty) (*SystemProxyStatus, error)
	SetSystemProxyEnabled(context.Context, *SetSystemProxyEnabledRequest) (*Response, error)
	LogListener(Core_LogListenerServer) error
	mustEmbedUnimplementedCoreServer()
}

// UnimplementedCoreServer must be embedded to have forward compatible implementations.
type UnimplementedCoreServer struct {
}

func (UnimplementedCoreServer) Start(context.Context, *StartRequest) (*CoreInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Start not implemented")
}
func (UnimplementedCoreServer) CoreInfoListener(Core_CoreInfoListenerServer) error {
	return status.Errorf(codes.Unimplemented, "method CoreInfoListener not implemented")
}
func (UnimplementedCoreServer) OutboundsInfo(Core_OutboundsInfoServer) error {
	return status.Errorf(codes.Unimplemented, "method OutboundsInfo not implemented")
}
func (UnimplementedCoreServer) MainOutboundsInfo(Core_MainOutboundsInfoServer) error {
	return status.Errorf(codes.Unimplemented, "method MainOutboundsInfo not implemented")
}
func (UnimplementedCoreServer) GetSystemInfo(Core_GetSystemInfoServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSystemInfo not implemented")
}
func (UnimplementedCoreServer) Setup(context.Context, *SetupRequest) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Setup not implemented")
}
func (UnimplementedCoreServer) Parse(context.Context, *ParseRequest) (*ParseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Parse not implemented")
}
func (UnimplementedCoreServer) ChangeConfigOptions(context.Context, *ChangeConfigOptionsRequest) (*CoreInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChangeConfigOptions not implemented")
}
func (UnimplementedCoreServer) StartService(context.Context, *StartRequest) (*CoreInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartService not implemented")
}
func (UnimplementedCoreServer) Stop(context.Context, *Empty) (*CoreInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented")
}
func (UnimplementedCoreServer) Restart(context.Context, *StartRequest) (*CoreInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Restart not implemented")
}
func (UnimplementedCoreServer) SelectOutbound(context.Context, *SelectOutboundRequest) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SelectOutbound not implemented")
}
func (UnimplementedCoreServer) UrlTest(context.Context, *UrlTestRequest) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UrlTest not implemented")
}
func (UnimplementedCoreServer) GenerateWarpConfig(context.Context, *GenerateWarpConfigRequest) (*WarpGenerationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateWarpConfig not implemented")
}
func (UnimplementedCoreServer) GetSystemProxyStatus(context.Context, *Empty) (*SystemProxyStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSystemProxyStatus not implemented")
}
func (UnimplementedCoreServer) SetSystemProxyEnabled(context.Context, *SetSystemProxyEnabledRequest) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetSystemProxyEnabled not implemented")
}
func (UnimplementedCoreServer) LogListener(Core_LogListenerServer) error {
	return status.Errorf(codes.Unimplemented, "method LogListener not implemented")
}
func (UnimplementedCoreServer) mustEmbedUnimplementedCoreServer() {}

// UnsafeCoreServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to CoreServer will
// result in compilation errors.
type UnsafeCoreServer interface {
	mustEmbedUnimplementedCoreServer()
}

func RegisterCoreServer(s grpc.ServiceRegistrar, srv CoreServer) {
	s.RegisterService(&Core_ServiceDesc, srv)
}

func _Core_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).Start(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_Start_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).Start(ctx, req.(*StartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_CoreInfoListener_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CoreServer).CoreInfoListener(&coreCoreInfoListenerServer{stream})
}

type Core_CoreInfoListenerServer interface {
	Send(*CoreInfoResponse) error
	Recv() (*StopRequest, error)
	grpc.ServerStream
}

type coreCoreInfoListenerServer struct {
	grpc.ServerStream
}

func (x *coreCoreInfoListenerServer) Send(m *CoreInfoResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *coreCoreInfoListenerServer) Recv() (*StopRequest, error) {
	m := new(StopRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Core_OutboundsInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CoreServer).OutboundsInfo(&coreOutboundsInfoServer{stream})
}

type Core_OutboundsInfoServer interface {
	Send(*OutboundGroupList) error
	Recv() (*StopRequest, error)
	grpc.ServerStream
}

type coreOutboundsInfoServer struct {
	grpc.ServerStream
}

func (x *coreOutboundsInfoServer) Send(m *OutboundGroupList) error {
	return x.ServerStream.SendMsg(m)
}

func (x *coreOutboundsInfoServer) Recv() (*StopRequest, error) {
	m := new(StopRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Core_MainOutboundsInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CoreServer).MainOutboundsInfo(&coreMainOutboundsInfoServer{stream})
}

type Core_MainOutboundsInfoServer interface {
	Send(*OutboundGroupList) error
	Recv() (*StopRequest, error)
	grpc.ServerStream
}

type coreMainOutboundsInfoServer struct {
	grpc.ServerStream
}

func (x *coreMainOutboundsInfoServer) Send(m *OutboundGroupList) error {
	return x.ServerStream.SendMsg(m)
}

func (x *coreMainOutboundsInfoServer) Recv() (*StopRequest, error) {
	m := new(StopRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Core_GetSystemInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CoreServer).GetSystemInfo(&coreGetSystemInfoServer{stream})
}

type Core_GetSystemInfoServer interface {
	Send(*SystemInfo) error
	Recv() (*StopRequest, error)
	grpc.ServerStream
}

type coreGetSystemInfoServer struct {
	grpc.ServerStream
}

func (x *coreGetSystemInfoServer) Send(m *SystemInfo) error {
	return x.ServerStream.SendMsg(m)
}

func (x *coreGetSystemInfoServer) Recv() (*StopRequest, error) {
	m := new(StopRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Core_Setup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).Setup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_Setup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).Setup(ctx, req.(*SetupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_Parse_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ParseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).Parse(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_Parse_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).Parse(ctx, req.(*ParseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_ChangeConfigOptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChangeConfigOptionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).ChangeConfigOptions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_ChangeConfigOptions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).ChangeConfigOptions(ctx, req.(*ChangeConfigOptionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_StartService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).StartService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_StartService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).StartService(ctx, req.(*StartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).Stop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_Stop_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).Stop(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_Restart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).Restart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_Restart_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).Restart(ctx, req.(*StartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_SelectOutbound_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SelectOutboundRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).SelectOutbound(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_SelectOutbound_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).SelectOutbound(ctx, req.(*SelectOutboundRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_UrlTest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UrlTestRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).UrlTest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_UrlTest_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).UrlTest(ctx, req.(*UrlTestRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_GenerateWarpConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateWarpConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).GenerateWarpConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_GenerateWarpConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).GenerateWarpConfig(ctx, req.(*GenerateWarpConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_GetSystemProxyStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).GetSystemProxyStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_GetSystemProxyStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).GetSystemProxyStatus(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_SetSystemProxyEnabled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSystemProxyEnabledRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CoreServer).SetSystemProxyEnabled(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Core_SetSystemProxyEnabled_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CoreServer).SetSystemProxyEnabled(ctx, req.(*SetSystemProxyEnabledRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Core_LogListener_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CoreServer).LogListener(&coreLogListenerServer{stream})
}

type Core_LogListenerServer interface {
	Send(*LogMessage) error
	Recv() (*StopRequest, error)
	grpc.ServerStream
}

type coreLogListenerServer struct {
	grpc.ServerStream
}

func (x *coreLogListenerServer) Send(m *LogMessage) error {
	return x.ServerStream.SendMsg(m)
}

func (x *coreLogListenerServer) Recv() (*StopRequest, error) {
	m := new(StopRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Core_ServiceDesc is the grpc.ServiceDesc for Core service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Core_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hiddifyrpc.Core",
	HandlerType: (*CoreServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Start",
			Handler:    _Core_Start_Handler,
		},
		{
			MethodName: "Setup",
			Handler:    _Core_Setup_Handler,
		},
		{
			MethodName: "Parse",
			Handler:    _Core_Parse_Handler,
		},
		{
			MethodName: "ChangeConfigOptions",
			Handler:    _Core_ChangeConfigOptions_Handler,
		},
		{
			MethodName: "StartService",
			Handler:    _Core_StartService_Handler,
		},
		{
			MethodName: "Stop",
			Handler:    _Core_Stop_Handler,
		},
		{
			MethodName: "Restart",
			Handler:    _Core_Restart_Handler,
		},
		{
			MethodName: "SelectOutbound",
			Handler:    _Core_SelectOutbound_Handler,
		},
		{
			MethodName: "UrlTest",
			Handler:    _Core_UrlTest_Handler,
		},
		{
			MethodName: "GenerateWarpConfig",
			Handler:    _Core_GenerateWarpConfig_Handler,
		},
		{
			MethodName: "GetSystemProxyStatus",
			Handler:    _Core_GetSystemProxyStatus_Handler,
		},
		{
			MethodName: "SetSystemProxyEnabled",
			Handler:    _Core_SetSystemProxyEnabled_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "CoreInfoListener",
			Handler:       _Core_CoreInfoListener_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "OutboundsInfo",
			Handler:       _Core_OutboundsInfo_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "MainOutboundsInfo",
			Handler:       _Core_MainOutboundsInfo_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "GetSystemInfo",
			Handler:       _Core_GetSystemInfo_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "LogListener",
			Handler:       _Core_LogListener_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "hiddifyrpc/hiddify.proto",
}

const (
	TunnelService_Start_FullMethodName  = "/hiddifyrpc.TunnelService/Start"
	TunnelService_Stop_FullMethodName   = "/hiddifyrpc.TunnelService/Stop"
	TunnelService_Status_FullMethodName = "/hiddifyrpc.TunnelService/Status"
	TunnelService_Exit_FullMethodName   = "/hiddifyrpc.TunnelService/Exit"
)

// TunnelServiceClient is the client API for TunnelService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type TunnelServiceClient interface {
	Start(ctx context.Context, in *TunnelStartRequest, opts ...grpc.CallOption) (*TunnelResponse, error)
	Stop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TunnelResponse, error)
	Status(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TunnelResponse, error)
	Exit(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TunnelResponse, error)
}

type tunnelServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTunnelServiceClient(cc grpc.ClientConnInterface) TunnelServiceClient {
	return &tunnelServiceClient{cc}
}

func (c *tunnelServiceClient) Start(ctx context.Context, in *TunnelStartRequest, opts ...grpc.CallOption) (*TunnelResponse, error) {
	out := new(TunnelResponse)
	err := c.cc.Invoke(ctx, TunnelService_Start_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tunnelServiceClient) Stop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TunnelResponse, error) {
	out := new(TunnelResponse)
	err := c.cc.Invoke(ctx, TunnelService_Stop_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tunnelServiceClient) Status(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TunnelResponse, error) {
	out := new(TunnelResponse)
	err := c.cc.Invoke(ctx, TunnelService_Status_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tunnelServiceClient) Exit(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TunnelResponse, error) {
	out := new(TunnelResponse)
	err := c.cc.Invoke(ctx, TunnelService_Exit_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TunnelServiceServer is the server API for TunnelService service.
// All implementations must embed UnimplementedTunnelServiceServer
// for forward compatibility
type TunnelServiceServer interface {
	Start(context.Context, *TunnelStartRequest) (*TunnelResponse, error)
	Stop(context.Context, *Empty) (*TunnelResponse, error)
	Status(context.Context, *Empty) (*TunnelResponse, error)
	Exit(context.Context, *Empty) (*TunnelResponse, error)
	mustEmbedUnimplementedTunnelServiceServer()
}

// UnimplementedTunnelServiceServer must be embedded to have forward compatible implementations.
type UnimplementedTunnelServiceServer struct {
}

func (UnimplementedTunnelServiceServer) Start(context.Context, *TunnelStartRequest) (*TunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Start not implemented")
}
func (UnimplementedTunnelServiceServer) Stop(context.Context, *Empty) (*TunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented")
}
func (UnimplementedTunnelServiceServer) Status(context.Context, *Empty) (*TunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Status not implemented")
}
func (UnimplementedTunnelServiceServer) Exit(context.Context, *Empty) (*TunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Exit not implemented")
}
func (UnimplementedTunnelServiceServer) mustEmbedUnimplementedTunnelServiceServer() {}

// UnsafeTunnelServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to TunnelServiceServer will
// result in compilation errors.
type UnsafeTunnelServiceServer interface {
	mustEmbedUnimplementedTunnelServiceServer()
}

func RegisterTunnelServiceServer(s grpc.ServiceRegistrar, srv TunnelServiceServer) {
	s.RegisterService(&TunnelService_ServiceDesc, srv)
}

func _TunnelService_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TunnelStartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TunnelServiceServer).Start(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TunnelService_Start_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TunnelServiceServer).Start(ctx, req.(*TunnelStartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TunnelService_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TunnelServiceServer).Stop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TunnelService_Stop_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TunnelServiceServer).Stop(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _TunnelService_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TunnelServiceServer).Status(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TunnelService_Status_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TunnelServiceServer).Status(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _TunnelService_Exit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TunnelServiceServer).Exit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TunnelService_Exit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TunnelServiceServer).Exit(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

// TunnelService_ServiceDesc is the grpc.ServiceDesc for TunnelService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TunnelService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hiddifyrpc.TunnelService",
	HandlerType: (*TunnelServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Start",
			Handler:    _TunnelService_Start_Handler,
		},
		{
			MethodName: "Stop",
			Handler:    _TunnelService_Stop_Handler,
		},
		{
			MethodName: "Status",
			Handler:    _TunnelService_Status_Handler,
		},
		{
			MethodName: "Exit",
			Handler:    _TunnelService_Exit_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "hiddifyrpc/hiddify.proto",
}