generic

type Args = igeneric.Args

type BidiStreamingServer interface {
	// Recv receives a message from the client.
	Recv(ctx context.Context) (req interface{}, err error)
	// Send sends a message to the client.
	Send(ctx context.Context, res interface{}) error
	// SetHeader inherits from the underlying streaming.ServerStream.
	SetHeader(hd streaming.Header) error
	// SendHeader inherits from the underlying streaming.ServerStream.
	SendHeader(hd streaming.Header) error
	// SetTrailer inherits from the underlying streaming.ServerStream.
	SetTrailer(hd streaming.Trailer) error
	// Streaming returns the underlying streaming.ServerStream.
	Streaming() streaming.ServerStream
}

type ClientStreamingServer interface {
	// Recv receives a message from the client.
	Recv(ctx context.Context) (req interface{}, err error)
	// SendAndClose sends a message to the client and closes the stream.
	SendAndClose(ctx context.Context, res interface{}) error
	// SetHeader inherits from the underlying streaming.ServerStream.
	SetHeader(hd streaming.Header) error
	// SendHeader inherits from the underlying streaming.ServerStream.
	SendHeader(hd streaming.Header) error
	// SetTrailer inherits from the underlying streaming.ServerStream.
	SetTrailer(hd streaming.Trailer) error
	// Streaming returns the underlying streaming.ServerStream.
	Streaming() streaming.ServerStream
}

type Closer interface {
	// Close the unused resource.
	Close() error
}

type DescriptorProvider interface {
	Closer
	// Provide return a channel for provide service descriptors
	Provide() <-chan *descriptor.ServiceDescriptor
}

type Generic interface {
	Closer
	// PayloadCodecType return the type of codec
	PayloadCodecType() serviceinfo.PayloadCodec
	// GenericMethod return generic method func
	GenericMethod() serviceinfo.GenericMethodFunc
	// IDLServiceName returns idl service name
	IDLServiceName() string
	// GetExtra returns extra info by key
	GetExtra(key string) interface{}
}

type GetMethodNameByRequestFunc func(req interface{}) (string, error)

type GetProviderOption interface {
	Option() ProviderOption
}

type HTTPRequest = descriptor.HTTPRequest

type HTTPResponse = descriptor.HTTPResponse

type Method struct {
	Oneway        bool
	StreamingMode serviceinfo.StreamingMode
}

type Option struct {
	F func(opt *Options)
}

type Options struct {
	// contains filtered or unexported fields
}

type PbContentProvider struct {
	// contains filtered or unexported fields
}

type PbDescriptorProvider interface {
	Closer
	// Provide return a channel for provide service descriptors
	Provide() <-chan proto.ServiceDescriptor
}

type PbDescriptorProviderDynamicGo interface {
	Closer
	// Provide return a channel for provide service descriptors
	Provide() <-chan *dproto.ServiceDescriptor
}

type PbFileProviderWithDynamicGo struct {
	// contains filtered or unexported fields
}

type ProviderOption struct {
	// DynamicGoEnabled is if dynamicgo is enabled or not
	DynamicGoEnabled bool
	// DynamicGoOptions is the options for dynamicgo parsing IDL
	// NOTICE: it WON'T override some default options for dynamicgo
	DynamicGoOptions *dthrift.Options
}

type Result = igeneric.Result

type ServerStreamingServer interface {
	// Send sends a message to the client.
	Send(ctx context.Context, res interface{}) error
	// SetHeader inherits from the underlying streaming.ServerStream.
	SetHeader(hd streaming.Header) error
	// SendHeader inherits from the underlying streaming.ServerStream.
	SendHeader(hd streaming.Header) error
	// SetTrailer inherits from the underlying streaming.ServerStream.
	SetTrailer(hd streaming.Trailer) error
	// Streaming returns the underlying streaming.ServerStream.
	Streaming() streaming.ServerStream
}

type Service interface {
	// GenericCall handle the generic call
	GenericCall(ctx context.Context, method string, request interface{}) (response interface{}, err error)
}

type ServiceV2 struct {
	// GenericCall handles pingpong/unary requests.
	//
	// NOTE: If the generic type is BinaryThriftGenericV2, GRPC unary requests won't be handled by this method.
	// Instead, they will be handled by BidiStreaming.
	GenericCall func(ctx context.Context, service, method string, request interface{}) (response interface{}, err error)

	// ClientStreaming handles client streaming call.
	//
	// NOTE: If the generic type is BinaryThriftGenericV2, Client streaming requests won't be handled by this method.
	// Instead, they will be handled by BidiStreaming.
	ClientStreaming func(ctx context.Context, service, method string, stream ClientStreamingServer) (err error)

	// ServerStreaming handles server streaming call.
	//
	// NOTE: If the generic type is BinaryThriftGenericV2, Server streaming requests won't be handled by this method.
	// Instead, they will be handled by BidiStreaming.
	ServerStreaming func(ctx context.Context, service, method string, request interface{}, stream ServerStreamingServer) (err error)

	// BidiStreaming handles the bidi streaming call.
	//
	// NOTE: If the generic type is BinaryThriftGenericV2, all streaming requests (including GRPC unary) will be handled
	// by this method. Since we cannot determine the stream mode without IDL info, we can only treat the requests
	// as bidi streaming by default.
	BidiStreaming func(ctx context.Context, service, method string, stream BidiStreamingServer) (err error)
}

type SetFieldsForEmptyStructMode uint8

type ThriftContentProvider struct {
	// contains filtered or unexported fields
}

type ThriftContentWithAbsIncludePathProvider struct {
	// contains filtered or unexported fields
}

type ThriftIDLProviderOption struct {
	F func(opt *thriftIDLProviderOptions)
}

type WithCodec interface {
	SetCodec(codec interface{})
}