foo.pb.yarpc.go

// Code generated by protoc-gen-yarpc-go
// source: foo/foo.proto
// DO NOT EDIT!

package foopb

import (
	"context"
	"io/ioutil"
	"reflect"

	"github.com/gogo/protobuf/proto"
	"github.com/uber/prototool/example/gen/proto/go/sub"
	"go.uber.org/fx"
	"go.uber.org/yarpc"
	"go.uber.org/yarpc/api/transport"
	"go.uber.org/yarpc/encoding/protobuf"
)

var _ = ioutil.NopCloser

// HelloServiceYARPCClient is the YARPC client-side interface for the HelloService service.
type HelloServiceYARPCClient interface {
	Foo(context.Context, *subpb.Dep, ...yarpc.CallOption) (*FooResponse, error)
	Bar(context.Context, *BarRequest, ...yarpc.CallOption) (*Dep, error)
}

// NewHelloServiceYARPCClient builds a new YARPC client for the HelloService service.
func NewHelloServiceYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) HelloServiceYARPCClient {
	return &_HelloServiceYARPCCaller{protobuf.NewStreamClient(
		protobuf.ClientParams{
			ServiceName:  "foo.HelloService",
			ClientConfig: clientConfig,
			Options:      options,
		},
	)}
}

// HelloServiceYARPCServer is the YARPC server-side interface for the HelloService service.
type HelloServiceYARPCServer interface {
	Foo(context.Context, *subpb.Dep) (*FooResponse, error)
	Bar(context.Context, *BarRequest) (*Dep, error)
}

// BuildHelloServiceYARPCProcedures prepares an implementation of the HelloService service for YARPC registration.
func BuildHelloServiceYARPCProcedures(server HelloServiceYARPCServer) []transport.Procedure {
	handler := &_HelloServiceYARPCHandler{server}
	return protobuf.BuildProcedures(
		protobuf.BuildProceduresParams{
			ServiceName: "foo.HelloService",
			UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{
				{
					MethodName: "Foo",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:     handler.Foo,
							NewRequest: newHelloServiceServiceFooYARPCRequest,
						},
					),
				},
				{
					MethodName: "Bar",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:     handler.Bar,
							NewRequest: newHelloServiceServiceBarYARPCRequest,
						},
					),
				},
			},
			OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
			StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
		},
	)
}

// FxHelloServiceYARPCClientParams defines the input
// for NewFxHelloServiceYARPCClient. It provides the
// paramaters to get a HelloServiceYARPCClient in an
// Fx application.
type FxHelloServiceYARPCClientParams struct {
	fx.In

	Provider yarpc.ClientConfig
}

// FxHelloServiceYARPCClientResult defines the output
// of NewFxHelloServiceYARPCClient. It provides a
// HelloServiceYARPCClient to an Fx application.
type FxHelloServiceYARPCClientResult struct {
	fx.Out

	Client HelloServiceYARPCClient

	// We are using an fx.Out struct here instead of just returning a client
	// so that we can add more values or add named versions of the client in
	// the future without breaking any existing code.
}

// NewFxHelloServiceYARPCClient provides a HelloServiceYARPCClient
// to an Fx application using the given name for routing.
//
//  fx.Provide(
//    foopb.NewFxHelloServiceYARPCClient("service-name"),
//    ...
//  )
func NewFxHelloServiceYARPCClient(name string, options ...protobuf.ClientOption) interface{} {
	return func(params FxHelloServiceYARPCClientParams) FxHelloServiceYARPCClientResult {
		return FxHelloServiceYARPCClientResult{
			Client: NewHelloServiceYARPCClient(params.Provider.ClientConfig(name), options...),
		}
	}
}

// FxHelloServiceYARPCProceduresParams defines the input
// for NewFxHelloServiceYARPCProcedures. It provides the
// paramaters to get HelloServiceYARPCServer procedures in an
// Fx application.
type FxHelloServiceYARPCProceduresParams struct {
	fx.In

	Server HelloServiceYARPCServer
}

// FxHelloServiceYARPCProceduresResult defines the output
// of NewFxHelloServiceYARPCProcedures. It provides
// HelloServiceYARPCServer procedures to an Fx application.
//
// The procedures are provided to the "yarpcfx" value group.
// Dig 1.2 or newer must be used for this feature to work.
type FxHelloServiceYARPCProceduresResult struct {
	fx.Out

	Procedures []transport.Procedure `group:"yarpcfx"`
}

// NewFxHelloServiceYARPCProcedures provides HelloServiceYARPCServer procedures to an Fx application.
// It expects a HelloServiceYARPCServer to be present in the container.
//
//  fx.Provide(
//    foopb.NewFxHelloServiceYARPCProcedures(),
//    ...
//  )
func NewFxHelloServiceYARPCProcedures() interface{} {
	return func(params FxHelloServiceYARPCProceduresParams) FxHelloServiceYARPCProceduresResult {
		return FxHelloServiceYARPCProceduresResult{
			Procedures: BuildHelloServiceYARPCProcedures(params.Server),
		}
	}
}

type _HelloServiceYARPCCaller struct {
	streamClient protobuf.StreamClient
}

func (c *_HelloServiceYARPCCaller) Foo(ctx context.Context, request *subpb.Dep, options ...yarpc.CallOption) (*FooResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "Foo", request, newHelloServiceServiceFooYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*FooResponse)
	if !ok {
		return nil, protobuf.CastError(emptyHelloServiceServiceFooYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_HelloServiceYARPCCaller) Bar(ctx context.Context, request *BarRequest, options ...yarpc.CallOption) (*Dep, error) {
	responseMessage, err := c.streamClient.Call(ctx, "Bar", request, newHelloServiceServiceBarYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*Dep)
	if !ok {
		return nil, protobuf.CastError(emptyHelloServiceServiceBarYARPCResponse, responseMessage)
	}
	return response, err
}

type _HelloServiceYARPCHandler struct {
	server HelloServiceYARPCServer
}

func (h *_HelloServiceYARPCHandler) Foo(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *subpb.Dep
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*subpb.Dep)
		if !ok {
			return nil, protobuf.CastError(emptyHelloServiceServiceFooYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.Foo(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_HelloServiceYARPCHandler) Bar(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *BarRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*BarRequest)
		if !ok {
			return nil, protobuf.CastError(emptyHelloServiceServiceBarYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.Bar(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func newHelloServiceServiceFooYARPCRequest() proto.Message {
	return &subpb.Dep{}
}

func newHelloServiceServiceFooYARPCResponse() proto.Message {
	return &FooResponse{}
}

func newHelloServiceServiceBarYARPCRequest() proto.Message {
	return &BarRequest{}
}

func newHelloServiceServiceBarYARPCResponse() proto.Message {
	return &Dep{}
}

var (
	emptyHelloServiceServiceFooYARPCRequest  = &subpb.Dep{}
	emptyHelloServiceServiceFooYARPCResponse = &FooResponse{}
	emptyHelloServiceServiceBarYARPCRequest  = &BarRequest{}
	emptyHelloServiceServiceBarYARPCResponse = &Dep{}
)

// ExcitedServiceYARPCClient is the YARPC client-side interface for the ExcitedService service.
type ExcitedServiceYARPCClient interface {
	Exclamation(context.Context, *ExclamationRequest, ...yarpc.CallOption) (*ExclamationResponse, error)
	ExclamationClientStream(context.Context, ...yarpc.CallOption) (ExcitedServiceServiceExclamationClientStreamYARPCClient, error)
	ExclamationServerStream(context.Context, *ExclamationRequest, ...yarpc.CallOption) (ExcitedServiceServiceExclamationServerStreamYARPCClient, error)
	ExclamationBidiStream(context.Context, ...yarpc.CallOption) (ExcitedServiceServiceExclamationBidiStreamYARPCClient, error)
}

// ExcitedServiceServiceExclamationClientStreamYARPCClient sends ExclamationRequests and receives the single ExclamationResponse when sending is done.
type ExcitedServiceServiceExclamationClientStreamYARPCClient interface {
	Context() context.Context
	Send(*ExclamationRequest, ...yarpc.StreamOption) error
	CloseAndRecv(...yarpc.StreamOption) (*ExclamationResponse, error)
}

// ExcitedServiceServiceExclamationServerStreamYARPCClient receives ExclamationResponses, returning io.EOF when the stream is complete.
type ExcitedServiceServiceExclamationServerStreamYARPCClient interface {
	Context() context.Context
	Recv(...yarpc.StreamOption) (*ExclamationResponse, error)
	CloseSend(...yarpc.StreamOption) error
}

// ExcitedServiceServiceExclamationBidiStreamYARPCClient sends ExclamationRequests and receives ExclamationResponses, returning io.EOF when the stream is complete.
type ExcitedServiceServiceExclamationBidiStreamYARPCClient interface {
	Context() context.Context
	Send(*ExclamationRequest, ...yarpc.StreamOption) error
	Recv(...yarpc.StreamOption) (*ExclamationResponse, error)
	CloseSend(...yarpc.StreamOption) error
}

// NewExcitedServiceYARPCClient builds a new YARPC client for the ExcitedService service.
func NewExcitedServiceYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) ExcitedServiceYARPCClient {
	return &_ExcitedServiceYARPCCaller{protobuf.NewStreamClient(
		protobuf.ClientParams{
			ServiceName:  "foo.ExcitedService",
			ClientConfig: clientConfig,
			Options:      options,
		},
	)}
}

// ExcitedServiceYARPCServer is the YARPC server-side interface for the ExcitedService service.
type ExcitedServiceYARPCServer interface {
	Exclamation(context.Context, *ExclamationRequest) (*ExclamationResponse, error)
	ExclamationClientStream(ExcitedServiceServiceExclamationClientStreamYARPCServer) (*ExclamationResponse, error)
	ExclamationServerStream(*ExclamationRequest, ExcitedServiceServiceExclamationServerStreamYARPCServer) error
	ExclamationBidiStream(ExcitedServiceServiceExclamationBidiStreamYARPCServer) error
}

// ExcitedServiceServiceExclamationClientStreamYARPCServer receives ExclamationRequests.
type ExcitedServiceServiceExclamationClientStreamYARPCServer interface {
	Context() context.Context
	Recv(...yarpc.StreamOption) (*ExclamationRequest, error)
}

// ExcitedServiceServiceExclamationServerStreamYARPCServer sends ExclamationResponses.
type ExcitedServiceServiceExclamationServerStreamYARPCServer interface {
	Context() context.Context
	Send(*ExclamationResponse, ...yarpc.StreamOption) error
}

// ExcitedServiceServiceExclamationBidiStreamYARPCServer receives ExclamationRequests and sends ExclamationResponse.
type ExcitedServiceServiceExclamationBidiStreamYARPCServer interface {
	Context() context.Context
	Recv(...yarpc.StreamOption) (*ExclamationRequest, error)
	Send(*ExclamationResponse, ...yarpc.StreamOption) error
}

// BuildExcitedServiceYARPCProcedures prepares an implementation of the ExcitedService service for YARPC registration.
func BuildExcitedServiceYARPCProcedures(server ExcitedServiceYARPCServer) []transport.Procedure {
	handler := &_ExcitedServiceYARPCHandler{server}
	return protobuf.BuildProcedures(
		protobuf.BuildProceduresParams{
			ServiceName: "foo.ExcitedService",
			UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{
				{
					MethodName: "Exclamation",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:     handler.Exclamation,
							NewRequest: newExcitedServiceServiceExclamationYARPCRequest,
						},
					),
				},
			},
			OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
			StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{
				{
					MethodName: "ExclamationBidiStream",
					Handler: protobuf.NewStreamHandler(
						protobuf.StreamHandlerParams{
							Handle: handler.ExclamationBidiStream,
						},
					),
				},

				{
					MethodName: "ExclamationServerStream",
					Handler: protobuf.NewStreamHandler(
						protobuf.StreamHandlerParams{
							Handle: handler.ExclamationServerStream,
						},
					),
				},

				{
					MethodName: "ExclamationClientStream",
					Handler: protobuf.NewStreamHandler(
						protobuf.StreamHandlerParams{
							Handle: handler.ExclamationClientStream,
						},
					),
				},
			},
		},
	)
}

// FxExcitedServiceYARPCClientParams defines the input
// for NewFxExcitedServiceYARPCClient. It provides the
// paramaters to get a ExcitedServiceYARPCClient in an
// Fx application.
type FxExcitedServiceYARPCClientParams struct {
	fx.In

	Provider yarpc.ClientConfig
}

// FxExcitedServiceYARPCClientResult defines the output
// of NewFxExcitedServiceYARPCClient. It provides a
// ExcitedServiceYARPCClient to an Fx application.
type FxExcitedServiceYARPCClientResult struct {
	fx.Out

	Client ExcitedServiceYARPCClient

	// We are using an fx.Out struct here instead of just returning a client
	// so that we can add more values or add named versions of the client in
	// the future without breaking any existing code.
}

// NewFxExcitedServiceYARPCClient provides a ExcitedServiceYARPCClient
// to an Fx application using the given name for routing.
//
//  fx.Provide(
//    foopb.NewFxExcitedServiceYARPCClient("service-name"),
//    ...
//  )
func NewFxExcitedServiceYARPCClient(name string, options ...protobuf.ClientOption) interface{} {
	return func(params FxExcitedServiceYARPCClientParams) FxExcitedServiceYARPCClientResult {
		return FxExcitedServiceYARPCClientResult{
			Client: NewExcitedServiceYARPCClient(params.Provider.ClientConfig(name), options...),
		}
	}
}

// FxExcitedServiceYARPCProceduresParams defines the input
// for NewFxExcitedServiceYARPCProcedures. It provides the
// paramaters to get ExcitedServiceYARPCServer procedures in an
// Fx application.
type FxExcitedServiceYARPCProceduresParams struct {
	fx.In

	Server ExcitedServiceYARPCServer
}

// FxExcitedServiceYARPCProceduresResult defines the output
// of NewFxExcitedServiceYARPCProcedures. It provides
// ExcitedServiceYARPCServer procedures to an Fx application.
//
// The procedures are provided to the "yarpcfx" value group.
// Dig 1.2 or newer must be used for this feature to work.
type FxExcitedServiceYARPCProceduresResult struct {
	fx.Out

	Procedures []transport.Procedure `group:"yarpcfx"`
}

// NewFxExcitedServiceYARPCProcedures provides ExcitedServiceYARPCServer procedures to an Fx application.
// It expects a ExcitedServiceYARPCServer to be present in the container.
//
//  fx.Provide(
//    foopb.NewFxExcitedServiceYARPCProcedures(),
//    ...
//  )
func NewFxExcitedServiceYARPCProcedures() interface{} {
	return func(params FxExcitedServiceYARPCProceduresParams) FxExcitedServiceYARPCProceduresResult {
		return FxExcitedServiceYARPCProceduresResult{
			Procedures: BuildExcitedServiceYARPCProcedures(params.Server),
		}
	}
}

type _ExcitedServiceYARPCCaller struct {
	streamClient protobuf.StreamClient
}

func (c *_ExcitedServiceYARPCCaller) Exclamation(ctx context.Context, request *ExclamationRequest, options ...yarpc.CallOption) (*ExclamationResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "Exclamation", request, newExcitedServiceServiceExclamationYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ExclamationResponse)
	if !ok {
		return nil, protobuf.CastError(emptyExcitedServiceServiceExclamationYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_ExcitedServiceYARPCCaller) ExclamationClientStream(ctx context.Context, options ...yarpc.CallOption) (ExcitedServiceServiceExclamationClientStreamYARPCClient, error) {
	stream, err := c.streamClient.CallStream(ctx, "ExclamationClientStream", options...)
	if err != nil {
		return nil, err
	}
	return &_ExcitedServiceServiceExclamationClientStreamYARPCClient{stream: stream}, nil
}

func (c *_ExcitedServiceYARPCCaller) ExclamationServerStream(ctx context.Context, request *ExclamationRequest, options ...yarpc.CallOption) (ExcitedServiceServiceExclamationServerStreamYARPCClient, error) {
	stream, err := c.streamClient.CallStream(ctx, "ExclamationServerStream", options...)
	if err != nil {
		return nil, err
	}
	if err := stream.Send(request); err != nil {
		return nil, err
	}
	return &_ExcitedServiceServiceExclamationServerStreamYARPCClient{stream: stream}, nil
}

func (c *_ExcitedServiceYARPCCaller) ExclamationBidiStream(ctx context.Context, options ...yarpc.CallOption) (ExcitedServiceServiceExclamationBidiStreamYARPCClient, error) {
	stream, err := c.streamClient.CallStream(ctx, "ExclamationBidiStream", options...)
	if err != nil {
		return nil, err
	}
	return &_ExcitedServiceServiceExclamationBidiStreamYARPCClient{stream: stream}, nil
}

type _ExcitedServiceYARPCHandler struct {
	server ExcitedServiceYARPCServer
}

func (h *_ExcitedServiceYARPCHandler) Exclamation(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *ExclamationRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*ExclamationRequest)
		if !ok {
			return nil, protobuf.CastError(emptyExcitedServiceServiceExclamationYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.Exclamation(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_ExcitedServiceYARPCHandler) ExclamationClientStream(serverStream *protobuf.ServerStream) error {
	response, err := h.server.ExclamationClientStream(&_ExcitedServiceServiceExclamationClientStreamYARPCServer{serverStream: serverStream})
	if err != nil {
		return err
	}
	return serverStream.Send(response)
}

func (h *_ExcitedServiceYARPCHandler) ExclamationServerStream(serverStream *protobuf.ServerStream) error {
	requestMessage, err := serverStream.Receive(newExcitedServiceServiceExclamationServerStreamYARPCRequest)
	if requestMessage == nil {
		return err
	}

	request, ok := requestMessage.(*ExclamationRequest)
	if !ok {
		return protobuf.CastError(emptyExcitedServiceServiceExclamationServerStreamYARPCRequest, requestMessage)
	}
	return h.server.ExclamationServerStream(request, &_ExcitedServiceServiceExclamationServerStreamYARPCServer{serverStream: serverStream})
}

func (h *_ExcitedServiceYARPCHandler) ExclamationBidiStream(serverStream *protobuf.ServerStream) error {
	return h.server.ExclamationBidiStream(&_ExcitedServiceServiceExclamationBidiStreamYARPCServer{serverStream: serverStream})
}

type _ExcitedServiceServiceExclamationClientStreamYARPCClient struct {
	stream *protobuf.ClientStream
}

func (c *_ExcitedServiceServiceExclamationClientStreamYARPCClient) Context() context.Context {
	return c.stream.Context()
}

func (c *_ExcitedServiceServiceExclamationClientStreamYARPCClient) Send(request *ExclamationRequest, options ...yarpc.StreamOption) error {
	return c.stream.Send(request, options...)
}

func (c *_ExcitedServiceServiceExclamationClientStreamYARPCClient) CloseAndRecv(options ...yarpc.StreamOption) (*ExclamationResponse, error) {
	if err := c.stream.Close(options...); err != nil {
		return nil, err
	}
	responseMessage, err := c.stream.Receive(newExcitedServiceServiceExclamationClientStreamYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ExclamationResponse)
	if !ok {
		return nil, protobuf.CastError(emptyExcitedServiceServiceExclamationClientStreamYARPCResponse, responseMessage)
	}
	return response, err
}

type _ExcitedServiceServiceExclamationServerStreamYARPCClient struct {
	stream *protobuf.ClientStream
}

func (c *_ExcitedServiceServiceExclamationServerStreamYARPCClient) Context() context.Context {
	return c.stream.Context()
}

func (c *_ExcitedServiceServiceExclamationServerStreamYARPCClient) Recv(options ...yarpc.StreamOption) (*ExclamationResponse, error) {
	responseMessage, err := c.stream.Receive(newExcitedServiceServiceExclamationServerStreamYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ExclamationResponse)
	if !ok {
		return nil, protobuf.CastError(emptyExcitedServiceServiceExclamationServerStreamYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_ExcitedServiceServiceExclamationServerStreamYARPCClient) CloseSend(options ...yarpc.StreamOption) error {
	return c.stream.Close(options...)
}

type _ExcitedServiceServiceExclamationBidiStreamYARPCClient struct {
	stream *protobuf.ClientStream
}

func (c *_ExcitedServiceServiceExclamationBidiStreamYARPCClient) Context() context.Context {
	return c.stream.Context()
}

func (c *_ExcitedServiceServiceExclamationBidiStreamYARPCClient) Send(request *ExclamationRequest, options ...yarpc.StreamOption) error {
	return c.stream.Send(request, options...)
}

func (c *_ExcitedServiceServiceExclamationBidiStreamYARPCClient) Recv(options ...yarpc.StreamOption) (*ExclamationResponse, error) {
	responseMessage, err := c.stream.Receive(newExcitedServiceServiceExclamationBidiStreamYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ExclamationResponse)
	if !ok {
		return nil, protobuf.CastError(emptyExcitedServiceServiceExclamationBidiStreamYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_ExcitedServiceServiceExclamationBidiStreamYARPCClient) CloseSend(options ...yarpc.StreamOption) error {
	return c.stream.Close(options...)
}

type _ExcitedServiceServiceExclamationClientStreamYARPCServer struct {
	serverStream *protobuf.ServerStream
}

func (s *_ExcitedServiceServiceExclamationClientStreamYARPCServer) Context() context.Context {
	return s.serverStream.Context()
}

func (s *_ExcitedServiceServiceExclamationClientStreamYARPCServer) Recv(options ...yarpc.StreamOption) (*ExclamationRequest, error) {
	requestMessage, err := s.serverStream.Receive(newExcitedServiceServiceExclamationClientStreamYARPCRequest, options...)
	if requestMessage == nil {
		return nil, err
	}
	request, ok := requestMessage.(*ExclamationRequest)
	if !ok {
		return nil, protobuf.CastError(emptyExcitedServiceServiceExclamationClientStreamYARPCRequest, requestMessage)
	}
	return request, err
}

type _ExcitedServiceServiceExclamationServerStreamYARPCServer struct {
	serverStream *protobuf.ServerStream
}

func (s *_ExcitedServiceServiceExclamationServerStreamYARPCServer) Context() context.Context {
	return s.serverStream.Context()
}

func (s *_ExcitedServiceServiceExclamationServerStreamYARPCServer) Send(response *ExclamationResponse, options ...yarpc.StreamOption) error {
	return s.serverStream.Send(response, options...)
}

type _ExcitedServiceServiceExclamationBidiStreamYARPCServer struct {
	serverStream *protobuf.ServerStream
}

func (s *_ExcitedServiceServiceExclamationBidiStreamYARPCServer) Context() context.Context {
	return s.serverStream.Context()
}

func (s *_ExcitedServiceServiceExclamationBidiStreamYARPCServer) Recv(options ...yarpc.StreamOption) (*ExclamationRequest, error) {
	requestMessage, err := s.serverStream.Receive(newExcitedServiceServiceExclamationBidiStreamYARPCRequest, options...)
	if requestMessage == nil {
		return nil, err
	}
	request, ok := requestMessage.(*ExclamationRequest)
	if !ok {
		return nil, protobuf.CastError(emptyExcitedServiceServiceExclamationBidiStreamYARPCRequest, requestMessage)
	}
	return request, err
}

func (s *_ExcitedServiceServiceExclamationBidiStreamYARPCServer) Send(response *ExclamationResponse, options ...yarpc.StreamOption) error {
	return s.serverStream.Send(response, options...)
}

func newExcitedServiceServiceExclamationYARPCRequest() proto.Message {
	return &ExclamationRequest{}
}

func newExcitedServiceServiceExclamationYARPCResponse() proto.Message {
	return &ExclamationResponse{}
}

func newExcitedServiceServiceExclamationClientStreamYARPCRequest() proto.Message {
	return &ExclamationRequest{}
}

func newExcitedServiceServiceExclamationClientStreamYARPCResponse() proto.Message {
	return &ExclamationResponse{}
}

func newExcitedServiceServiceExclamationServerStreamYARPCRequest() proto.Message {
	return &ExclamationRequest{}
}

func newExcitedServiceServiceExclamationServerStreamYARPCResponse() proto.Message {
	return &ExclamationResponse{}
}

func newExcitedServiceServiceExclamationBidiStreamYARPCRequest() proto.Message {
	return &ExclamationRequest{}
}

func newExcitedServiceServiceExclamationBidiStreamYARPCResponse() proto.Message {
	return &ExclamationResponse{}
}

var (
	emptyExcitedServiceServiceExclamationYARPCRequest              = &ExclamationRequest{}
	emptyExcitedServiceServiceExclamationYARPCResponse             = &ExclamationResponse{}
	emptyExcitedServiceServiceExclamationClientStreamYARPCRequest  = &ExclamationRequest{}
	emptyExcitedServiceServiceExclamationClientStreamYARPCResponse = &ExclamationResponse{}
	emptyExcitedServiceServiceExclamationServerStreamYARPCRequest  = &ExclamationRequest{}
	emptyExcitedServiceServiceExclamationServerStreamYARPCResponse = &ExclamationResponse{}
	emptyExcitedServiceServiceExclamationBidiStreamYARPCRequest    = &ExclamationRequest{}
	emptyExcitedServiceServiceExclamationBidiStreamYARPCResponse   = &ExclamationResponse{}
)

func init() {
	yarpc.RegisterClientBuilder(
		func(clientConfig transport.ClientConfig, structField reflect.StructField) HelloServiceYARPCClient {
			return NewHelloServiceYARPCClient(clientConfig, protobuf.ClientBuilderOptions(clientConfig, structField)...)
		},
	)
	yarpc.RegisterClientBuilder(
		func(clientConfig transport.ClientConfig, structField reflect.StructField) ExcitedServiceYARPCClient {
			return NewExcitedServiceYARPCClient(clientConfig, protobuf.ClientBuilderOptions(clientConfig, structField)...)
		},
	)
}