runtime

type Call interface {
	// Send sends an input message to the call.
	//
	// u is an unmarshaler that produces the input message.
	// err is the error produced by the unmarshaler.
	//
	// more is true if the call can accept additional input messages.
	Send(u Unmarshaler) (more bool, err error)

	// Done is called to indicate that no more input messages will be sent.
	Done()

	// Recv returns the next output message produced by this call.
	//
	// more is true if the call can produce additional output messages.
	//
	// err is the error returned by the RPC method, if any.
	Recv() (out proto.Message, more bool, err error)
}

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

type ClientOptions struct {
	HTTPClient      *http.Client
	InputMediaType  string
	OutputMediaType string
}

type Method interface {
	// Name returns the name of the RPC method.
	Name() string

	// InputIsStream returns true if the method accepts a stream of input
	// messages, as opposed to a single input message.
	InputIsStream() bool

	// OutputIsStream returns true if the method produces a stream of output
	// messages, as opposed to a single output message.
	OutputIsStream() bool

	// NewCall starts a new call to the method.
	//
	// ctx is the context for the lifetime of the call, including any time taken
	// to stream input and output messages.
	NewCall(ctx context.Context, i middleware.ServerInterceptor) Call
}

type Registry interface {
	RegisterService(Service)
}

type Service interface {
	// Name returns the unqualified service name.
	Name() string

	// Package returns the Protocol Buffers package name in which the service is
	// defined.
	Package() string

	// MethodByName returns the method with the given name.
	//
	// If no such method exists, ok is false.
	MethodByName(name string) (_ Method, ok bool)
}

type Unmarshaler func(m proto.Message) error