// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.0
// - protoc             v3.21.12
// source: hold.proto

package clngrpc_hold

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.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	Hold_GetInfo_FullMethodName       = "/hold.Hold/GetInfo"
	Hold_Invoice_FullMethodName       = "/hold.Hold/Invoice"
	Hold_Inject_FullMethodName        = "/hold.Hold/Inject"
	Hold_List_FullMethodName          = "/hold.Hold/List"
	Hold_Settle_FullMethodName        = "/hold.Hold/Settle"
	Hold_Cancel_FullMethodName        = "/hold.Hold/Cancel"
	Hold_Clean_FullMethodName         = "/hold.Hold/Clean"
	Hold_Track_FullMethodName         = "/hold.Hold/Track"
	Hold_TrackAll_FullMethodName      = "/hold.Hold/TrackAll"
	Hold_OnionMessages_FullMethodName = "/hold.Hold/OnionMessages"
)

// HoldClient is the client API for Hold 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 HoldClient interface {
	GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error)
	Invoice(ctx context.Context, in *InvoiceRequest, opts ...grpc.CallOption) (*InvoiceResponse, error)
	Inject(ctx context.Context, in *InjectRequest, opts ...grpc.CallOption) (*InjectResponse, error)
	List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)
	Settle(ctx context.Context, in *SettleRequest, opts ...grpc.CallOption) (*SettleResponse, error)
	Cancel(ctx context.Context, in *CancelRequest, opts ...grpc.CallOption) (*CancelResponse, error)
	// Cleans cancelled invoices
	Clean(ctx context.Context, in *CleanRequest, opts ...grpc.CallOption) (*CleanResponse, error)
	Track(ctx context.Context, in *TrackRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[TrackResponse], error)
	TrackAll(ctx context.Context, in *TrackAllRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[TrackAllResponse], error)
	OnionMessages(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[OnionMessageResponse, OnionMessage], error)
}

type holdClient struct {
	cc grpc.ClientConnInterface
}

func NewHoldClient(cc grpc.ClientConnInterface) HoldClient {
	return &holdClient{cc}
}

func (c *holdClient) GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetInfoResponse)
	err := c.cc.Invoke(ctx, Hold_GetInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *holdClient) Invoice(ctx context.Context, in *InvoiceRequest, opts ...grpc.CallOption) (*InvoiceResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InvoiceResponse)
	err := c.cc.Invoke(ctx, Hold_Invoice_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *holdClient) Inject(ctx context.Context, in *InjectRequest, opts ...grpc.CallOption) (*InjectResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InjectResponse)
	err := c.cc.Invoke(ctx, Hold_Inject_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *holdClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListResponse)
	err := c.cc.Invoke(ctx, Hold_List_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *holdClient) Settle(ctx context.Context, in *SettleRequest, opts ...grpc.CallOption) (*SettleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SettleResponse)
	err := c.cc.Invoke(ctx, Hold_Settle_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *holdClient) Cancel(ctx context.Context, in *CancelRequest, opts ...grpc.CallOption) (*CancelResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CancelResponse)
	err := c.cc.Invoke(ctx, Hold_Cancel_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *holdClient) Clean(ctx context.Context, in *CleanRequest, opts ...grpc.CallOption) (*CleanResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CleanResponse)
	err := c.cc.Invoke(ctx, Hold_Clean_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *holdClient) Track(ctx context.Context, in *TrackRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[TrackResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Hold_ServiceDesc.Streams[0], Hold_Track_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[TrackRequest, TrackResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type Hold_TrackClient = grpc.ServerStreamingClient[TrackResponse]

func (c *holdClient) TrackAll(ctx context.Context, in *TrackAllRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[TrackAllResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Hold_ServiceDesc.Streams[1], Hold_TrackAll_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[TrackAllRequest, TrackAllResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type Hold_TrackAllClient = grpc.ServerStreamingClient[TrackAllResponse]

func (c *holdClient) OnionMessages(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[OnionMessageResponse, OnionMessage], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Hold_ServiceDesc.Streams[2], Hold_OnionMessages_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[OnionMessageResponse, OnionMessage]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type Hold_OnionMessagesClient = grpc.BidiStreamingClient[OnionMessageResponse, OnionMessage]

// HoldServer is the server API for Hold service.
// All implementations must embed UnimplementedHoldServer
// for forward compatibility.
type HoldServer interface {
	GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error)
	Invoice(context.Context, *InvoiceRequest) (*InvoiceResponse, error)
	Inject(context.Context, *InjectRequest) (*InjectResponse, error)
	List(context.Context, *ListRequest) (*ListResponse, error)
	Settle(context.Context, *SettleRequest) (*SettleResponse, error)
	Cancel(context.Context, *CancelRequest) (*CancelResponse, error)
	// Cleans cancelled invoices
	Clean(context.Context, *CleanRequest) (*CleanResponse, error)
	Track(*TrackRequest, grpc.ServerStreamingServer[TrackResponse]) error
	TrackAll(*TrackAllRequest, grpc.ServerStreamingServer[TrackAllResponse]) error
	OnionMessages(grpc.BidiStreamingServer[OnionMessageResponse, OnionMessage]) error
	mustEmbedUnimplementedHoldServer()
}

// UnimplementedHoldServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedHoldServer struct{}

func (UnimplementedHoldServer) GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetInfo not implemented")
}
func (UnimplementedHoldServer) Invoice(context.Context, *InvoiceRequest) (*InvoiceResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Invoice not implemented")
}
func (UnimplementedHoldServer) Inject(context.Context, *InjectRequest) (*InjectResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Inject not implemented")
}
func (UnimplementedHoldServer) List(context.Context, *ListRequest) (*ListResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedHoldServer) Settle(context.Context, *SettleRequest) (*SettleResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Settle not implemented")
}
func (UnimplementedHoldServer) Cancel(context.Context, *CancelRequest) (*CancelResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Cancel not implemented")
}
func (UnimplementedHoldServer) Clean(context.Context, *CleanRequest) (*CleanResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Clean not implemented")
}
func (UnimplementedHoldServer) Track(*TrackRequest, grpc.ServerStreamingServer[TrackResponse]) error {
	return status.Error(codes.Unimplemented, "method Track not implemented")
}
func (UnimplementedHoldServer) TrackAll(*TrackAllRequest, grpc.ServerStreamingServer[TrackAllResponse]) error {
	return status.Error(codes.Unimplemented, "method TrackAll not implemented")
}
func (UnimplementedHoldServer) OnionMessages(grpc.BidiStreamingServer[OnionMessageResponse, OnionMessage]) error {
	return status.Error(codes.Unimplemented, "method OnionMessages not implemented")
}
func (UnimplementedHoldServer) mustEmbedUnimplementedHoldServer() {}
func (UnimplementedHoldServer) testEmbeddedByValue()              {}

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

func RegisterHoldServer(s grpc.ServiceRegistrar, srv HoldServer) {
	// If the following call panics, it indicates UnimplementedHoldServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&Hold_ServiceDesc, srv)
}

func _Hold_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HoldServer).GetInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Hold_GetInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HoldServer).GetInfo(ctx, req.(*GetInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Hold_Invoice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InvoiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HoldServer).Invoice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Hold_Invoice_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HoldServer).Invoice(ctx, req.(*InvoiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Hold_Inject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HoldServer).Inject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Hold_Inject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HoldServer).Inject(ctx, req.(*InjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Hold_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HoldServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Hold_List_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HoldServer).List(ctx, req.(*ListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Hold_Settle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SettleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HoldServer).Settle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Hold_Settle_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HoldServer).Settle(ctx, req.(*SettleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Hold_Cancel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HoldServer).Cancel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Hold_Cancel_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HoldServer).Cancel(ctx, req.(*CancelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Hold_Clean_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CleanRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HoldServer).Clean(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Hold_Clean_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HoldServer).Clean(ctx, req.(*CleanRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Hold_Track_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TrackRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(HoldServer).Track(m, &grpc.GenericServerStream[TrackRequest, TrackResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type Hold_TrackServer = grpc.ServerStreamingServer[TrackResponse]

func _Hold_TrackAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TrackAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(HoldServer).TrackAll(m, &grpc.GenericServerStream[TrackAllRequest, TrackAllResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type Hold_TrackAllServer = grpc.ServerStreamingServer[TrackAllResponse]

func _Hold_OnionMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(HoldServer).OnionMessages(&grpc.GenericServerStream[OnionMessageResponse, OnionMessage]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type Hold_OnionMessagesServer = grpc.BidiStreamingServer[OnionMessageResponse, OnionMessage]

// Hold_ServiceDesc is the grpc.ServiceDesc for Hold service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Hold_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hold.Hold",
	HandlerType: (*HoldServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetInfo",
			Handler:    _Hold_GetInfo_Handler,
		},
		{
			MethodName: "Invoice",
			Handler:    _Hold_Invoice_Handler,
		},
		{
			MethodName: "Inject",
			Handler:    _Hold_Inject_Handler,
		},
		{
			MethodName: "List",
			Handler:    _Hold_List_Handler,
		},
		{
			MethodName: "Settle",
			Handler:    _Hold_Settle_Handler,
		},
		{
			MethodName: "Cancel",
			Handler:    _Hold_Cancel_Handler,
		},
		{
			MethodName: "Clean",
			Handler:    _Hold_Clean_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Track",
			Handler:       _Hold_Track_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "TrackAll",
			Handler:       _Hold_TrackAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "OnionMessages",
			Handler:       _Hold_OnionMessages_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "hold.proto",
}