// Code generated by protoc-gen-go. DO NOT EDIT.
// source: remotecontrol.proto

package remotecontrol

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type NetworkState_State int32

const (
	NetworkState_None       NetworkState_State = 0
	NetworkState_Idle       NetworkState_State = 1
	NetworkState_Learning   NetworkState_State = 2
	NetworkState_Validation NetworkState_State = 3
	NetworkState_Predict    NetworkState_State = 4
)

var NetworkState_State_name = map[int32]string{
	0: "None",
	1: "Idle",
	2: "Learning",
	3: "Validation",
	4: "Predict",
}

var NetworkState_State_value = map[string]int32{
	"None":       0,
	"Idle":       1,
	"Learning":   2,
	"Validation": 3,
	"Predict":    4,
}

func (x NetworkState_State) String() string {
	return proto.EnumName(NetworkState_State_name, int32(x))
}

func (NetworkState_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9e7470c0107e56c6, []int{0, 0}
}

type LayerMatrix_ContentType int32

const (
	LayerMatrix_Activations LayerMatrix_ContentType = 0
	LayerMatrix_Weights     LayerMatrix_ContentType = 1
	LayerMatrix_Biases      LayerMatrix_ContentType = 2
)

var LayerMatrix_ContentType_name = map[int32]string{
	0: "Activations",
	1: "Weights",
	2: "Biases",
}

var LayerMatrix_ContentType_value = map[string]int32{
	"Activations": 0,
	"Weights":     1,
	"Biases":      2,
}

func (x LayerMatrix_ContentType) String() string {
	return proto.EnumName(LayerMatrix_ContentType_name, int32(x))
}

func (LayerMatrix_ContentType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9e7470c0107e56c6, []int{2, 0}
}

type NetworkState struct {
	State                NetworkState_State `protobuf:"varint,1,opt,name=state,proto3,enum=remotecontrol.NetworkState_State" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *NetworkState) Reset()         { *m = NetworkState{} }
func (m *NetworkState) String() string { return proto.CompactTextString(m) }
func (*NetworkState) ProtoMessage()    {}
func (*NetworkState) Descriptor() ([]byte, []int) {
	return fileDescriptor_9e7470c0107e56c6, []int{0}
}

func (m *NetworkState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NetworkState.Unmarshal(m, b)
}
func (m *NetworkState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NetworkState.Marshal(b, m, deterministic)
}
func (m *NetworkState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkState.Merge(m, src)
}
func (m *NetworkState) XXX_Size() int {
	return xxx_messageInfo_NetworkState.Size(m)
}
func (m *NetworkState) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkState.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkState proto.InternalMessageInfo

func (m *NetworkState) GetState() NetworkState_State {
	if m != nil {
		return m.State
	}
	return NetworkState_None
}

type Matrix struct {
	Matrix               []byte   `protobuf:"bytes,1,opt,name=matrix,proto3" json:"matrix,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Matrix) Reset()         { *m = Matrix{} }
func (m *Matrix) String() string { return proto.CompactTextString(m) }
func (*Matrix) ProtoMessage()    {}
func (*Matrix) Descriptor() ([]byte, []int) {
	return fileDescriptor_9e7470c0107e56c6, []int{1}
}

func (m *Matrix) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Matrix.Unmarshal(m, b)
}
func (m *Matrix) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Matrix.Marshal(b, m, deterministic)
}
func (m *Matrix) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Matrix.Merge(m, src)
}
func (m *Matrix) XXX_Size() int {
	return xxx_messageInfo_Matrix.Size(m)
}
func (m *Matrix) XXX_DiscardUnknown() {
	xxx_messageInfo_Matrix.DiscardUnknown(m)
}

var xxx_messageInfo_Matrix proto.InternalMessageInfo

func (m *Matrix) GetMatrix() []byte {
	if m != nil {
		return m.Matrix
	}
	return nil
}

type LayerMatrix struct {
	ContentType          LayerMatrix_ContentType `protobuf:"varint,1,opt,name=contentType,proto3,enum=remotecontrol.LayerMatrix_ContentType" json:"contentType,omitempty"`
	Layer                int32                   `protobuf:"zigzag32,2,opt,name=layer,proto3" json:"layer,omitempty"`
	Matrix               *Matrix                 `protobuf:"bytes,3,opt,name=matrix,proto3" json:"matrix,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *LayerMatrix) Reset()         { *m = LayerMatrix{} }
func (m *LayerMatrix) String() string { return proto.CompactTextString(m) }
func (*LayerMatrix) ProtoMessage()    {}
func (*LayerMatrix) Descriptor() ([]byte, []int) {
	return fileDescriptor_9e7470c0107e56c6, []int{2}
}

func (m *LayerMatrix) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LayerMatrix.Unmarshal(m, b)
}
func (m *LayerMatrix) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LayerMatrix.Marshal(b, m, deterministic)
}
func (m *LayerMatrix) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LayerMatrix.Merge(m, src)
}
func (m *LayerMatrix) XXX_Size() int {
	return xxx_messageInfo_LayerMatrix.Size(m)
}
func (m *LayerMatrix) XXX_DiscardUnknown() {
	xxx_messageInfo_LayerMatrix.DiscardUnknown(m)
}

var xxx_messageInfo_LayerMatrix proto.InternalMessageInfo

func (m *LayerMatrix) GetContentType() LayerMatrix_ContentType {
	if m != nil {
		return m.ContentType
	}
	return LayerMatrix_Activations
}

func (m *LayerMatrix) GetLayer() int32 {
	if m != nil {
		return m.Layer
	}
	return 0
}

func (m *LayerMatrix) GetMatrix() *Matrix {
	if m != nil {
		return m.Matrix
	}
	return nil
}

type Configuration struct {
	Sizes                []int32  `protobuf:"zigzag32,1,rep,packed,name=sizes,proto3" json:"sizes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Configuration) Reset()         { *m = Configuration{} }
func (m *Configuration) String() string { return proto.CompactTextString(m) }
func (*Configuration) ProtoMessage()    {}
func (*Configuration) Descriptor() ([]byte, []int) {
	return fileDescriptor_9e7470c0107e56c6, []int{3}
}

func (m *Configuration) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Configuration.Unmarshal(m, b)
}
func (m *Configuration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Configuration.Marshal(b, m, deterministic)
}
func (m *Configuration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Configuration.Merge(m, src)
}
func (m *Configuration) XXX_Size() int {
	return xxx_messageInfo_Configuration.Size(m)
}
func (m *Configuration) XXX_DiscardUnknown() {
	xxx_messageInfo_Configuration.DiscardUnknown(m)
}

var xxx_messageInfo_Configuration proto.InternalMessageInfo

func (m *Configuration) GetSizes() []int32 {
	if m != nil {
		return m.Sizes
	}
	return nil
}

type None struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *None) Reset()         { *m = None{} }
func (m *None) String() string { return proto.CompactTextString(m) }
func (*None) ProtoMessage()    {}
func (*None) Descriptor() ([]byte, []int) {
	return fileDescriptor_9e7470c0107e56c6, []int{4}
}

func (m *None) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_None.Unmarshal(m, b)
}
func (m *None) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_None.Marshal(b, m, deterministic)
}
func (m *None) XXX_Merge(src proto.Message) {
	xxx_messageInfo_None.Merge(m, src)
}
func (m *None) XXX_Size() int {
	return xxx_messageInfo_None.Size(m)
}
func (m *None) XXX_DiscardUnknown() {
	xxx_messageInfo_None.DiscardUnknown(m)
}

var xxx_messageInfo_None proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("remotecontrol.NetworkState_State", NetworkState_State_name, NetworkState_State_value)
	proto.RegisterEnum("remotecontrol.LayerMatrix_ContentType", LayerMatrix_ContentType_name, LayerMatrix_ContentType_value)
	proto.RegisterType((*NetworkState)(nil), "remotecontrol.NetworkState")
	proto.RegisterType((*Matrix)(nil), "remotecontrol.Matrix")
	proto.RegisterType((*LayerMatrix)(nil), "remotecontrol.LayerMatrix")
	proto.RegisterType((*Configuration)(nil), "remotecontrol.Configuration")
	proto.RegisterType((*None)(nil), "remotecontrol.None")
}

func init() { proto.RegisterFile("remotecontrol.proto", fileDescriptor_9e7470c0107e56c6) }

var fileDescriptor_9e7470c0107e56c6 = []byte{
	// 394 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x4f, 0x6f, 0xda, 0x30,
	0x18, 0xc6, 0xe3, 0x00, 0x19, 0x7a, 0x03, 0xcc, 0x33, 0xdb, 0x84, 0xd8, 0x0e, 0x99, 0xa5, 0x4d,
	0x5c, 0x16, 0x4d, 0xec, 0xc0, 0x69, 0x93, 0x06, 0xd2, 0xfe, 0x48, 0x0c, 0x4d, 0xd9, 0xb4, 0x9e,
	0x53, 0x70, 0x53, 0xab, 0xc1, 0x46, 0x8e, 0xfb, 0x87, 0x7e, 0x89, 0x7e, 0xba, 0x5e, 0xfa, 0x69,
	0x2a, 0x3b, 0x40, 0x93, 0x88, 0xf6, 0xc0, 0x05, 0xbd, 0xaf, 0xf5, 0x3c, 0x8f, 0x7f, 0xef, 0x8b,
	0x03, 0x5d, 0xc5, 0x96, 0x52, 0xb3, 0xb9, 0x14, 0x5a, 0xc9, 0x34, 0x5c, 0x29, 0xa9, 0x25, 0x69,
	0x97, 0x0e, 0xe9, 0x0d, 0x82, 0xd6, 0x8c, 0xe9, 0x4b, 0xa9, 0xce, 0xfe, 0xea, 0x58, 0x33, 0x32,
	0x82, 0x46, 0x66, 0x8a, 0x1e, 0x0a, 0xd0, 0xa0, 0x33, 0x7c, 0x17, 0x96, 0x43, 0x8a, 0xda, 0xd0,
	0xfe, 0x46, 0xb9, 0x9e, 0x7e, 0x87, 0x46, 0x9e, 0xd0, 0x84, 0xfa, 0x4c, 0x0a, 0x86, 0x1d, 0x53,
	0xfd, 0x5a, 0xa4, 0x0c, 0x23, 0xd2, 0x82, 0xe6, 0x94, 0xc5, 0x4a, 0x70, 0x91, 0x60, 0x97, 0x74,
	0x00, 0xfe, 0xc7, 0x29, 0x5f, 0xc4, 0x9a, 0x4b, 0x81, 0x6b, 0xc4, 0x87, 0x67, 0x7f, 0x14, 0x5b,
	0xf0, 0xb9, 0xc6, 0x75, 0x1a, 0x80, 0xf7, 0x3b, 0xd6, 0x8a, 0x5f, 0x91, 0xd7, 0xe0, 0x2d, 0x6d,
	0x65, 0x59, 0x5a, 0xd1, 0xa6, 0xa3, 0xb7, 0x08, 0xfc, 0x69, 0xbc, 0x66, 0x6a, 0xa3, 0xfb, 0x09,
	0xbe, 0xc1, 0x63, 0x42, 0xff, 0x5b, 0xaf, 0xb6, 0xe0, 0x1f, 0x2a, 0xe0, 0x05, 0x43, 0x38, 0x79,
	0x50, 0x47, 0x45, 0x2b, 0x79, 0x09, 0x8d, 0xd4, 0xe8, 0x7a, 0x6e, 0x80, 0x06, 0x2f, 0xa2, 0xbc,
	0x21, 0x1f, 0x77, 0x1c, 0xb5, 0x00, 0x0d, 0xfc, 0xe1, 0xab, 0x4a, 0x74, 0x9e, 0xba, 0xc3, 0x1b,
	0x81, 0x5f, 0xb8, 0x80, 0x3c, 0x07, 0xff, 0xdb, 0x5c, 0xf3, 0x0b, 0x3b, 0x6c, 0x86, 0x1d, 0x33,
	0xed, 0x11, 0xe3, 0xc9, 0xa9, 0xce, 0x30, 0x22, 0x00, 0xde, 0x98, 0xc7, 0x19, 0xcb, 0xb0, 0x4b,
	0xdf, 0x43, 0x7b, 0x22, 0xc5, 0x09, 0x4f, 0xce, 0x95, 0x15, 0x1b, 0x9c, 0x8c, 0x5f, 0xb3, 0xac,
	0x87, 0x82, 0x9a, 0xc1, 0xb1, 0x0d, 0xf5, 0xf2, 0xfd, 0x0e, 0xef, 0x5c, 0x68, 0x47, 0x16, 0x64,
	0x92, 0x83, 0x90, 0x1f, 0x80, 0x13, 0xa6, 0xcb, 0x19, 0xdd, 0xea, 0x1f, 0x28, 0x05, 0xeb, 0xbf,
	0xad, 0x1c, 0x96, 0x2c, 0xd4, 0x21, 0xe3, 0x12, 0xf3, 0xfe, 0x8c, 0xfe, 0xe3, 0x0b, 0xa6, 0xce,
	0x27, 0x44, 0xbe, 0x6c, 0x27, 0x3b, 0xcc, 0xfe, 0x75, 0xb7, 0xa5, 0x43, 0xaf, 0xdf, 0x3c, 0xc7,
	0xbd, 0xee, 0x37, 0x4f, 0x3c, 0x6b, 0x63, 0x3f, 0xf6, 0xec, 0xd7, 0xf2, 0xf9, 0x3e, 0x00, 0x00,
	0xff, 0xff, 0xa7, 0xea, 0x3c, 0x30, 0x44, 0x03, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// RemoteControlClient is the client API for RemoteControl service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RemoteControlClient interface {
	GetConfiguration(ctx context.Context, in *None, opts ...grpc.CallOption) (*Configuration, error)
	Activations(ctx context.Context, in *None, opts ...grpc.CallOption) (RemoteControl_ActivationsClient, error)
	Biases(ctx context.Context, in *None, opts ...grpc.CallOption) (RemoteControl_BiasesClient, error)
	Weights(ctx context.Context, in *None, opts ...grpc.CallOption) (RemoteControl_WeightsClient, error)
	State(ctx context.Context, in *None, opts ...grpc.CallOption) (RemoteControl_StateClient, error)
}

type remoteControlClient struct {
	cc grpc.ClientConnInterface
}

func NewRemoteControlClient(cc grpc.ClientConnInterface) RemoteControlClient {
	return &remoteControlClient{cc}
}

func (c *remoteControlClient) GetConfiguration(ctx context.Context, in *None, opts ...grpc.CallOption) (*Configuration, error) {
	out := new(Configuration)
	err := c.cc.Invoke(ctx, "/remotecontrol.RemoteControl/getConfiguration", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *remoteControlClient) Activations(ctx context.Context, in *None, opts ...grpc.CallOption) (RemoteControl_ActivationsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RemoteControl_serviceDesc.Streams[0], "/remotecontrol.RemoteControl/Activations", opts...)
	if err != nil {
		return nil, err
	}
	x := &remoteControlActivationsClient{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
}

type RemoteControl_ActivationsClient interface {
	Recv() (*LayerMatrix, error)
	grpc.ClientStream
}

type remoteControlActivationsClient struct {
	grpc.ClientStream
}

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

func (c *remoteControlClient) Biases(ctx context.Context, in *None, opts ...grpc.CallOption) (RemoteControl_BiasesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RemoteControl_serviceDesc.Streams[1], "/remotecontrol.RemoteControl/Biases", opts...)
	if err != nil {
		return nil, err
	}
	x := &remoteControlBiasesClient{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
}

type RemoteControl_BiasesClient interface {
	Recv() (*LayerMatrix, error)
	grpc.ClientStream
}

type remoteControlBiasesClient struct {
	grpc.ClientStream
}

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

func (c *remoteControlClient) Weights(ctx context.Context, in *None, opts ...grpc.CallOption) (RemoteControl_WeightsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RemoteControl_serviceDesc.Streams[2], "/remotecontrol.RemoteControl/Weights", opts...)
	if err != nil {
		return nil, err
	}
	x := &remoteControlWeightsClient{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
}

type RemoteControl_WeightsClient interface {
	Recv() (*LayerMatrix, error)
	grpc.ClientStream
}

type remoteControlWeightsClient struct {
	grpc.ClientStream
}

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

func (c *remoteControlClient) State(ctx context.Context, in *None, opts ...grpc.CallOption) (RemoteControl_StateClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RemoteControl_serviceDesc.Streams[3], "/remotecontrol.RemoteControl/State", opts...)
	if err != nil {
		return nil, err
	}
	x := &remoteControlStateClient{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
}

type RemoteControl_StateClient interface {
	Recv() (*NetworkState, error)
	grpc.ClientStream
}

type remoteControlStateClient struct {
	grpc.ClientStream
}

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

// RemoteControlServer is the server API for RemoteControl service.
type RemoteControlServer interface {
	GetConfiguration(context.Context, *None) (*Configuration, error)
	Activations(*None, RemoteControl_ActivationsServer) error
	Biases(*None, RemoteControl_BiasesServer) error
	Weights(*None, RemoteControl_WeightsServer) error
	State(*None, RemoteControl_StateServer) error
}

// UnimplementedRemoteControlServer can be embedded to have forward compatible implementations.
type UnimplementedRemoteControlServer struct {
}

func (*UnimplementedRemoteControlServer) GetConfiguration(ctx context.Context, req *None) (*Configuration, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConfiguration not implemented")
}
func (*UnimplementedRemoteControlServer) Activations(req *None, srv RemoteControl_ActivationsServer) error {
	return status.Errorf(codes.Unimplemented, "method Activations not implemented")
}
func (*UnimplementedRemoteControlServer) Biases(req *None, srv RemoteControl_BiasesServer) error {
	return status.Errorf(codes.Unimplemented, "method Biases not implemented")
}
func (*UnimplementedRemoteControlServer) Weights(req *None, srv RemoteControl_WeightsServer) error {
	return status.Errorf(codes.Unimplemented, "method Weights not implemented")
}
func (*UnimplementedRemoteControlServer) State(req *None, srv RemoteControl_StateServer) error {
	return status.Errorf(codes.Unimplemented, "method State not implemented")
}

func RegisterRemoteControlServer(s *grpc.Server, srv RemoteControlServer) {
	s.RegisterService(&_RemoteControl_serviceDesc, srv)
}

func _RemoteControl_GetConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(None)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RemoteControlServer).GetConfiguration(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remotecontrol.RemoteControl/GetConfiguration",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RemoteControlServer).GetConfiguration(ctx, req.(*None))
	}
	return interceptor(ctx, in, info, handler)
}

func _RemoteControl_Activations_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(None)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RemoteControlServer).Activations(m, &remoteControlActivationsServer{stream})
}

type RemoteControl_ActivationsServer interface {
	Send(*LayerMatrix) error
	grpc.ServerStream
}

type remoteControlActivationsServer struct {
	grpc.ServerStream
}

func (x *remoteControlActivationsServer) Send(m *LayerMatrix) error {
	return x.ServerStream.SendMsg(m)
}

func _RemoteControl_Biases_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(None)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RemoteControlServer).Biases(m, &remoteControlBiasesServer{stream})
}

type RemoteControl_BiasesServer interface {
	Send(*LayerMatrix) error
	grpc.ServerStream
}

type remoteControlBiasesServer struct {
	grpc.ServerStream
}

func (x *remoteControlBiasesServer) Send(m *LayerMatrix) error {
	return x.ServerStream.SendMsg(m)
}

func _RemoteControl_Weights_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(None)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RemoteControlServer).Weights(m, &remoteControlWeightsServer{stream})
}

type RemoteControl_WeightsServer interface {
	Send(*LayerMatrix) error
	grpc.ServerStream
}

type remoteControlWeightsServer struct {
	grpc.ServerStream
}

func (x *remoteControlWeightsServer) Send(m *LayerMatrix) error {
	return x.ServerStream.SendMsg(m)
}

func _RemoteControl_State_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(None)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RemoteControlServer).State(m, &remoteControlStateServer{stream})
}

type RemoteControl_StateServer interface {
	Send(*NetworkState) error
	grpc.ServerStream
}

type remoteControlStateServer struct {
	grpc.ServerStream
}

func (x *remoteControlStateServer) Send(m *NetworkState) error {
	return x.ServerStream.SendMsg(m)
}

var _RemoteControl_serviceDesc = grpc.ServiceDesc{
	ServiceName: "remotecontrol.RemoteControl",
	HandlerType: (*RemoteControlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "getConfiguration",
			Handler:    _RemoteControl_GetConfiguration_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Activations",
			Handler:       _RemoteControl_Activations_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Biases",
			Handler:       _RemoteControl_Biases_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Weights",
			Handler:       _RemoteControl_Weights_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "State",
			Handler:       _RemoteControl_State_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "remotecontrol.proto",
}