localworker.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: localworker.proto

package v1

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"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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

// DiscoverRequest is sent when the netmanager wants to local worker to
// probe its locally attached devices.
type DiscoverRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DiscoverRequest) Reset()         { *m = DiscoverRequest{} }
func (m *DiscoverRequest) String() string { return proto.CompactTextString(m) }
func (*DiscoverRequest) ProtoMessage()    {}
func (*DiscoverRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d9116c22e0c2dd1, []int{0}
}
func (m *DiscoverRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DiscoverRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DiscoverRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DiscoverRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DiscoverRequest.Merge(m, src)
}
func (m *DiscoverRequest) XXX_Size() int {
	return m.Size()
}
func (m *DiscoverRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DiscoverRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DiscoverRequest proto.InternalMessageInfo

// DiscoverResult is returned in a response to a discover request by the netmanager.
type DiscoverResult struct {
	// ID of local worker
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The addresses that were found
	Addresses            []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DiscoverResult) Reset()         { *m = DiscoverResult{} }
func (m *DiscoverResult) String() string { return proto.CompactTextString(m) }
func (*DiscoverResult) ProtoMessage()    {}
func (*DiscoverResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d9116c22e0c2dd1, []int{1}
}
func (m *DiscoverResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DiscoverResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DiscoverResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DiscoverResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DiscoverResult.Merge(m, src)
}
func (m *DiscoverResult) XXX_Size() int {
	return m.Size()
}
func (m *DiscoverResult) XXX_DiscardUnknown() {
	xxx_messageInfo_DiscoverResult.DiscardUnknown(m)
}

var xxx_messageInfo_DiscoverResult proto.InternalMessageInfo

func (m *DiscoverResult) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *DiscoverResult) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func init() {
	proto.RegisterType((*DiscoverRequest)(nil), "binkynet.v1.DiscoverRequest")
	proto.RegisterType((*DiscoverResult)(nil), "binkynet.v1.DiscoverResult")
}

func init() { proto.RegisterFile("localworker.proto", fileDescriptor_4d9116c22e0c2dd1) }

var fileDescriptor_4d9116c22e0c2dd1 = []byte{
	// 487 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x94, 0xc1, 0x6e, 0xd3, 0x40,
	0x10, 0x86, 0xd9, 0x80, 0x80, 0x4c, 0x45, 0x9a, 0x6c, 0x0e, 0x84, 0x50, 0x99, 0x12, 0x71, 0xc8,
	0xc9, 0x71, 0x0a, 0x12, 0x5c, 0x40, 0xb4, 0xb4, 0xb2, 0x2a, 0xaa, 0x36, 0x8a, 0x25, 0x90, 0xb8,
	0x39, 0xce, 0x34, 0x5d, 0xc5, 0xf5, 0x1a, 0xef, 0x38, 0x51, 0x9e, 0x04, 0x9e, 0x81, 0x27, 0xe1,
	0xc8, 0x23, 0xa0, 0xf0, 0x22, 0x28, 0x36, 0x4e, 0xb3, 0xae, 0x4d, 0x6e, 0xd9, 0xf9, 0xff, 0x7f,
	0xe6, 0x9b, 0x91, 0x62, 0x68, 0xf8, 0xd2, 0x73, 0xfd, 0xb9, 0x8c, 0xa6, 0x18, 0x99, 0x61, 0x24,
	0x49, 0xf2, 0x9d, 0x91, 0x08, 0xa6, 0x8b, 0x00, 0xc9, 0x9c, 0xf5, 0xdb, 0x3b, 0xb4, 0x08, 0x51,
	0xa5, 0x4a, 0xa7, 0x01, 0xbb, 0xc7, 0x42, 0x79, 0x72, 0x86, 0xd1, 0x10, 0xbf, 0xc6, 0xa8, 0xa8,
	0xf3, 0x0e, 0x6a, 0x37, 0x25, 0x15, 0xfb, 0xc4, 0x6b, 0x50, 0x11, 0xe3, 0x16, 0xdb, 0x67, 0xdd,
	0xea, 0xb0, 0x22, 0xc6, 0x7c, 0x0f, 0xaa, 0xee, 0x78, 0x1c, 0xa1, 0x52, 0xa8, 0x5a, 0x95, 0xfd,
	0xbb, 0xdd, 0xea, 0xf0, 0xa6, 0x70, 0x30, 0x81, 0xd6, 0xd9, 0x8a, 0xe0, 0x73, 0x42, 0xf0, 0x41,
	0x06, 0x97, 0x62, 0xe2, 0x60, 0x34, 0x13, 0x1e, 0xf2, 0x8f, 0x50, 0xb5, 0x91, 0xd2, 0x1a, 0xdf,
	0x33, 0x37, 0xb0, 0xcc, 0x8d, 0xcc, 0x69, 0x70, 0x29, 0xdb, 0x46, 0x99, 0x9a, 0xa6, 0x2d, 0x76,
	0xf0, 0xed, 0x01, 0x3c, 0xd1, 0xeb, 0x14, 0x49, 0x3f, 0x1b, 0xf5, 0x06, 0xee, 0x0d, 0x44, 0xb0,
	0x6d, 0x0a, 0xd7, 0xd4, 0x93, 0xeb, 0x90, 0x16, 0xdc, 0x81, 0xa6, 0x8d, 0x94, 0x3b, 0x8b, 0xda,
	0xd2, 0x48, 0x57, 0x73, 0x61, 0x8b, 0xf1, 0x63, 0x68, 0x38, 0x9b, 0x4d, 0x93, 0xc3, 0x3e, 0x2d,
	0x09, 0xad, 0xc4, 0x42, 0xb4, 0x01, 0xd4, 0x6d, 0xa4, 0x81, 0x9c, 0x6f, 0x70, 0x3d, 0xd7, 0x7c,
	0x9a, 0x76, 0x11, 0x92, 0x90, 0x81, 0x6a, 0x3f, 0xbe, 0x6d, 0x71, 0xc8, 0x25, 0xb4, 0x18, 0x7f,
	0x0f, 0xbb, 0xce, 0xbf, 0x8e, 0x87, 0x1e, 0xc5, 0xae, 0xaf, 0x78, 0x99, 0xbb, 0x88, 0xa8, 0xcb,
	0xf8, 0x09, 0xd4, 0x6c, 0xa4, 0x33, 0xe9, 0xad, 0x89, 0x9e, 0xe5, 0x2f, 0x95, 0xe7, 0xa9, 0xe7,
	0x0d, 0x16, 0xe3, 0xaf, 0xe1, 0x91, 0x93, 0xb4, 0xc9, 0x30, 0x6e, 0x99, 0x4a, 0xe6, 0xbf, 0x85,
	0xba, 0x83, 0xe4, 0x60, 0xa0, 0xe4, 0x7a, 0x85, 0xa6, 0xe6, 0x4c, 0xb5, 0x92, 0xf8, 0x39, 0x34,
	0x6c, 0xa4, 0x8b, 0x98, 0xc2, 0x98, 0xd6, 0x1b, 0x74, 0x34, 0xab, 0x2e, 0x66, 0x4b, 0x34, 0x0b,
	0x3c, 0x56, 0x86, 0x93, 0x3e, 0x8b, 0x71, 0x52, 0xed, 0xbf, 0x38, 0xce, 0x5c, 0x90, 0x77, 0x55,
	0x82, 0xa3, 0x8b, 0xc5, 0x38, 0xa9, 0x67, 0x8d, 0x93, 0x3e, 0x4b, 0xae, 0x93, 0x68, 0x25, 0x38,
	0xaf, 0xe0, 0xe1, 0xea, 0x0f, 0xeb, 0x4b, 0x6f, 0xca, 0x0b, 0x1c, 0xb9, 0x54, 0xe2, 0xb3, 0xd8,
	0xd1, 0xe9, 0xcf, 0xa5, 0xc1, 0x7e, 0x2d, 0x0d, 0xf6, 0x7b, 0x69, 0xb0, 0xef, 0x7f, 0x8c, 0x3b,
	0x5f, 0x5e, 0x4c, 0x04, 0x5d, 0xc5, 0x23, 0xd3, 0x93, 0xd7, 0xbd, 0x2c, 0xd1, 0x3b, 0x5a, 0xfd,
	0x38, 0x47, 0xea, 0xb9, 0xa1, 0x50, 0xbd, 0x59, 0xff, 0x47, 0xa5, 0x9e, 0x95, 0xcc, 0xc3, 0x50,
	0x28, 0xf3, 0x53, 0x7f, 0x74, 0x3f, 0xf9, 0x4e, 0xbd, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x8f,
	0x16, 0x88, 0xb2, 0xd6, 0x04, 0x00, 0x00,
}

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

// 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.SupportPackageIsVersion4

// LocalWorkerConfigServiceClient is the client API for LocalWorkerConfigService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LocalWorkerConfigServiceClient interface {
	// GetConfig is used to fetch the configuration for a local worker.
	GetConfig(ctx context.Context, in *LocalWorkerInfo, opts ...grpc.CallOption) (LocalWorkerConfigService_GetConfigClient, error)
}

type localWorkerConfigServiceClient struct {
	cc *grpc.ClientConn
}

func NewLocalWorkerConfigServiceClient(cc *grpc.ClientConn) LocalWorkerConfigServiceClient {
	return &localWorkerConfigServiceClient{cc}
}

func (c *localWorkerConfigServiceClient) GetConfig(ctx context.Context, in *LocalWorkerInfo, opts ...grpc.CallOption) (LocalWorkerConfigService_GetConfigClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerConfigService_serviceDesc.Streams[0], "/binkynet.v1.LocalWorkerConfigService/GetConfig", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerConfigServiceGetConfigClient{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 LocalWorkerConfigService_GetConfigClient interface {
	Recv() (*LocalWorkerConfig, error)
	grpc.ClientStream
}

type localWorkerConfigServiceGetConfigClient struct {
	grpc.ClientStream
}

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

// LocalWorkerConfigServiceServer is the server API for LocalWorkerConfigService service.
type LocalWorkerConfigServiceServer interface {
	// GetConfig is used to fetch the configuration for a local worker.
	GetConfig(*LocalWorkerInfo, LocalWorkerConfigService_GetConfigServer) error
}

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

func (*UnimplementedLocalWorkerConfigServiceServer) GetConfig(req *LocalWorkerInfo, srv LocalWorkerConfigService_GetConfigServer) error {
	return status.Errorf(codes.Unimplemented, "method GetConfig not implemented")
}

func RegisterLocalWorkerConfigServiceServer(s *grpc.Server, srv LocalWorkerConfigServiceServer) {
	s.RegisterService(&_LocalWorkerConfigService_serviceDesc, srv)
}

func _LocalWorkerConfigService_GetConfig_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LocalWorkerInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LocalWorkerConfigServiceServer).GetConfig(m, &localWorkerConfigServiceGetConfigServer{stream})
}

type LocalWorkerConfigService_GetConfigServer interface {
	Send(*LocalWorkerConfig) error
	grpc.ServerStream
}

type localWorkerConfigServiceGetConfigServer struct {
	grpc.ServerStream
}

func (x *localWorkerConfigServiceGetConfigServer) Send(m *LocalWorkerConfig) error {
	return x.ServerStream.SendMsg(m)
}

var _LocalWorkerConfigService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "binkynet.v1.LocalWorkerConfigService",
	HandlerType: (*LocalWorkerConfigServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetConfig",
			Handler:       _LocalWorkerConfigService_GetConfig_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "localworker.proto",
}

// LocalWorkerControlServiceClient is the client API for LocalWorkerControlService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LocalWorkerControlServiceClient interface {
	// Ping messages are send at regular intervals by local workers
	// as a heartbeat notification, as well as providing information about
	// versions.
	Ping(ctx context.Context, in *LocalWorkerInfo, opts ...grpc.CallOption) (*Empty, error)
	// GetDiscoverRequests is used to allow the netmanager to request a discovery by
	// the local worker.
	// The local worker in turn responds with a SetDiscoverResult call.
	GetDiscoverRequests(ctx context.Context, in *LocalWorkerInfo, opts ...grpc.CallOption) (LocalWorkerControlService_GetDiscoverRequestsClient, error)
	// SetDiscoverResult is called by the local worker in response to discover requests.
	SetDiscoverResult(ctx context.Context, in *DiscoverResult, opts ...grpc.CallOption) (*Empty, error)
	// GetPowerRequests is used to get a stream of power requests from the network
	// master.
	GetPowerRequests(ctx context.Context, in *PowerRequestsOptions, opts ...grpc.CallOption) (LocalWorkerControlService_GetPowerRequestsClient, error)
	// SetPowerActuals is used to send a stream of actual power statuses to
	// the network master.
	SetPowerActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetPowerActualsClient, error)
	// GetLocRequests is used to get a stream of loc requests from the network
	// master.
	// Note: Loc.actual field is not set.
	GetLocRequests(ctx context.Context, in *LocRequestsOptions, opts ...grpc.CallOption) (LocalWorkerControlService_GetLocRequestsClient, error)
	// SetLocActuals is used to send a stream of actual loc statuses to
	// the network master.
	// Note: Loc.request field must be set to the latest request.
	SetLocActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetLocActualsClient, error)
	// SetSensorActuals is used to send a stream of actual sensor statuses to
	// the network master.
	SetSensorActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetSensorActualsClient, error)
	// GetOutputRequests is used to get a stream of output requests from the network
	// master.
	GetOutputRequests(ctx context.Context, in *OutputRequestsOptions, opts ...grpc.CallOption) (LocalWorkerControlService_GetOutputRequestsClient, error)
	// SetOutputActuals is used to send a stream of actual output statuses to
	// the network master.
	SetOutputActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetOutputActualsClient, error)
	// GetSwitchRequests is used to get a stream of switch requests from the network
	// master.
	GetSwitchRequests(ctx context.Context, in *SwitchRequestsOptions, opts ...grpc.CallOption) (LocalWorkerControlService_GetSwitchRequestsClient, error)
	// SetSwitchActuals is used to send a stream of actual switch statuses to
	// the network master.
	SetSwitchActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetSwitchActualsClient, error)
	// GetClock is used to get a stream of switch current time of day from the network
	// master.
	GetClock(ctx context.Context, in *Empty, opts ...grpc.CallOption) (LocalWorkerControlService_GetClockClient, error)
}

type localWorkerControlServiceClient struct {
	cc *grpc.ClientConn
}

func NewLocalWorkerControlServiceClient(cc *grpc.ClientConn) LocalWorkerControlServiceClient {
	return &localWorkerControlServiceClient{cc}
}

func (c *localWorkerControlServiceClient) Ping(ctx context.Context, in *LocalWorkerInfo, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/binkynet.v1.LocalWorkerControlService/Ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *localWorkerControlServiceClient) GetDiscoverRequests(ctx context.Context, in *LocalWorkerInfo, opts ...grpc.CallOption) (LocalWorkerControlService_GetDiscoverRequestsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[0], "/binkynet.v1.LocalWorkerControlService/GetDiscoverRequests", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceGetDiscoverRequestsClient{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 LocalWorkerControlService_GetDiscoverRequestsClient interface {
	Recv() (*DiscoverRequest, error)
	grpc.ClientStream
}

type localWorkerControlServiceGetDiscoverRequestsClient struct {
	grpc.ClientStream
}

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

func (c *localWorkerControlServiceClient) SetDiscoverResult(ctx context.Context, in *DiscoverResult, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/binkynet.v1.LocalWorkerControlService/SetDiscoverResult", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *localWorkerControlServiceClient) GetPowerRequests(ctx context.Context, in *PowerRequestsOptions, opts ...grpc.CallOption) (LocalWorkerControlService_GetPowerRequestsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[1], "/binkynet.v1.LocalWorkerControlService/GetPowerRequests", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceGetPowerRequestsClient{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 LocalWorkerControlService_GetPowerRequestsClient interface {
	Recv() (*PowerState, error)
	grpc.ClientStream
}

type localWorkerControlServiceGetPowerRequestsClient struct {
	grpc.ClientStream
}

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

func (c *localWorkerControlServiceClient) SetPowerActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetPowerActualsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[2], "/binkynet.v1.LocalWorkerControlService/SetPowerActuals", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceSetPowerActualsClient{stream}
	return x, nil
}

type LocalWorkerControlService_SetPowerActualsClient interface {
	Send(*PowerState) error
	CloseAndRecv() (*Empty, error)
	grpc.ClientStream
}

type localWorkerControlServiceSetPowerActualsClient struct {
	grpc.ClientStream
}

func (x *localWorkerControlServiceSetPowerActualsClient) Send(m *PowerState) error {
	return x.ClientStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetPowerActualsClient) CloseAndRecv() (*Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *localWorkerControlServiceClient) GetLocRequests(ctx context.Context, in *LocRequestsOptions, opts ...grpc.CallOption) (LocalWorkerControlService_GetLocRequestsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[3], "/binkynet.v1.LocalWorkerControlService/GetLocRequests", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceGetLocRequestsClient{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 LocalWorkerControlService_GetLocRequestsClient interface {
	Recv() (*Loc, error)
	grpc.ClientStream
}

type localWorkerControlServiceGetLocRequestsClient struct {
	grpc.ClientStream
}

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

func (c *localWorkerControlServiceClient) SetLocActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetLocActualsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[4], "/binkynet.v1.LocalWorkerControlService/SetLocActuals", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceSetLocActualsClient{stream}
	return x, nil
}

type LocalWorkerControlService_SetLocActualsClient interface {
	Send(*Loc) error
	CloseAndRecv() (*Empty, error)
	grpc.ClientStream
}

type localWorkerControlServiceSetLocActualsClient struct {
	grpc.ClientStream
}

func (x *localWorkerControlServiceSetLocActualsClient) Send(m *Loc) error {
	return x.ClientStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetLocActualsClient) CloseAndRecv() (*Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *localWorkerControlServiceClient) SetSensorActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetSensorActualsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[5], "/binkynet.v1.LocalWorkerControlService/SetSensorActuals", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceSetSensorActualsClient{stream}
	return x, nil
}

type LocalWorkerControlService_SetSensorActualsClient interface {
	Send(*Sensor) error
	CloseAndRecv() (*Empty, error)
	grpc.ClientStream
}

type localWorkerControlServiceSetSensorActualsClient struct {
	grpc.ClientStream
}

func (x *localWorkerControlServiceSetSensorActualsClient) Send(m *Sensor) error {
	return x.ClientStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetSensorActualsClient) CloseAndRecv() (*Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *localWorkerControlServiceClient) GetOutputRequests(ctx context.Context, in *OutputRequestsOptions, opts ...grpc.CallOption) (LocalWorkerControlService_GetOutputRequestsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[6], "/binkynet.v1.LocalWorkerControlService/GetOutputRequests", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceGetOutputRequestsClient{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 LocalWorkerControlService_GetOutputRequestsClient interface {
	Recv() (*Output, error)
	grpc.ClientStream
}

type localWorkerControlServiceGetOutputRequestsClient struct {
	grpc.ClientStream
}

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

func (c *localWorkerControlServiceClient) SetOutputActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetOutputActualsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[7], "/binkynet.v1.LocalWorkerControlService/SetOutputActuals", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceSetOutputActualsClient{stream}
	return x, nil
}

type LocalWorkerControlService_SetOutputActualsClient interface {
	Send(*Output) error
	CloseAndRecv() (*Empty, error)
	grpc.ClientStream
}

type localWorkerControlServiceSetOutputActualsClient struct {
	grpc.ClientStream
}

func (x *localWorkerControlServiceSetOutputActualsClient) Send(m *Output) error {
	return x.ClientStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetOutputActualsClient) CloseAndRecv() (*Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *localWorkerControlServiceClient) GetSwitchRequests(ctx context.Context, in *SwitchRequestsOptions, opts ...grpc.CallOption) (LocalWorkerControlService_GetSwitchRequestsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[8], "/binkynet.v1.LocalWorkerControlService/GetSwitchRequests", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceGetSwitchRequestsClient{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 LocalWorkerControlService_GetSwitchRequestsClient interface {
	Recv() (*Switch, error)
	grpc.ClientStream
}

type localWorkerControlServiceGetSwitchRequestsClient struct {
	grpc.ClientStream
}

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

func (c *localWorkerControlServiceClient) SetSwitchActuals(ctx context.Context, opts ...grpc.CallOption) (LocalWorkerControlService_SetSwitchActualsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[9], "/binkynet.v1.LocalWorkerControlService/SetSwitchActuals", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceSetSwitchActualsClient{stream}
	return x, nil
}

type LocalWorkerControlService_SetSwitchActualsClient interface {
	Send(*Switch) error
	CloseAndRecv() (*Empty, error)
	grpc.ClientStream
}

type localWorkerControlServiceSetSwitchActualsClient struct {
	grpc.ClientStream
}

func (x *localWorkerControlServiceSetSwitchActualsClient) Send(m *Switch) error {
	return x.ClientStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetSwitchActualsClient) CloseAndRecv() (*Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *localWorkerControlServiceClient) GetClock(ctx context.Context, in *Empty, opts ...grpc.CallOption) (LocalWorkerControlService_GetClockClient, error) {
	stream, err := c.cc.NewStream(ctx, &_LocalWorkerControlService_serviceDesc.Streams[10], "/binkynet.v1.LocalWorkerControlService/GetClock", opts...)
	if err != nil {
		return nil, err
	}
	x := &localWorkerControlServiceGetClockClient{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 LocalWorkerControlService_GetClockClient interface {
	Recv() (*Clock, error)
	grpc.ClientStream
}

type localWorkerControlServiceGetClockClient struct {
	grpc.ClientStream
}

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

// LocalWorkerControlServiceServer is the server API for LocalWorkerControlService service.
type LocalWorkerControlServiceServer interface {
	// Ping messages are send at regular intervals by local workers
	// as a heartbeat notification, as well as providing information about
	// versions.
	Ping(context.Context, *LocalWorkerInfo) (*Empty, error)
	// GetDiscoverRequests is used to allow the netmanager to request a discovery by
	// the local worker.
	// The local worker in turn responds with a SetDiscoverResult call.
	GetDiscoverRequests(*LocalWorkerInfo, LocalWorkerControlService_GetDiscoverRequestsServer) error
	// SetDiscoverResult is called by the local worker in response to discover requests.
	SetDiscoverResult(context.Context, *DiscoverResult) (*Empty, error)
	// GetPowerRequests is used to get a stream of power requests from the network
	// master.
	GetPowerRequests(*PowerRequestsOptions, LocalWorkerControlService_GetPowerRequestsServer) error
	// SetPowerActuals is used to send a stream of actual power statuses to
	// the network master.
	SetPowerActuals(LocalWorkerControlService_SetPowerActualsServer) error
	// GetLocRequests is used to get a stream of loc requests from the network
	// master.
	// Note: Loc.actual field is not set.
	GetLocRequests(*LocRequestsOptions, LocalWorkerControlService_GetLocRequestsServer) error
	// SetLocActuals is used to send a stream of actual loc statuses to
	// the network master.
	// Note: Loc.request field must be set to the latest request.
	SetLocActuals(LocalWorkerControlService_SetLocActualsServer) error
	// SetSensorActuals is used to send a stream of actual sensor statuses to
	// the network master.
	SetSensorActuals(LocalWorkerControlService_SetSensorActualsServer) error
	// GetOutputRequests is used to get a stream of output requests from the network
	// master.
	GetOutputRequests(*OutputRequestsOptions, LocalWorkerControlService_GetOutputRequestsServer) error
	// SetOutputActuals is used to send a stream of actual output statuses to
	// the network master.
	SetOutputActuals(LocalWorkerControlService_SetOutputActualsServer) error
	// GetSwitchRequests is used to get a stream of switch requests from the network
	// master.
	GetSwitchRequests(*SwitchRequestsOptions, LocalWorkerControlService_GetSwitchRequestsServer) error
	// SetSwitchActuals is used to send a stream of actual switch statuses to
	// the network master.
	SetSwitchActuals(LocalWorkerControlService_SetSwitchActualsServer) error
	// GetClock is used to get a stream of switch current time of day from the network
	// master.
	GetClock(*Empty, LocalWorkerControlService_GetClockServer) error
}

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

func (*UnimplementedLocalWorkerControlServiceServer) Ping(ctx context.Context, req *LocalWorkerInfo) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) GetDiscoverRequests(req *LocalWorkerInfo, srv LocalWorkerControlService_GetDiscoverRequestsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetDiscoverRequests not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) SetDiscoverResult(ctx context.Context, req *DiscoverResult) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetDiscoverResult not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) GetPowerRequests(req *PowerRequestsOptions, srv LocalWorkerControlService_GetPowerRequestsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetPowerRequests not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) SetPowerActuals(srv LocalWorkerControlService_SetPowerActualsServer) error {
	return status.Errorf(codes.Unimplemented, "method SetPowerActuals not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) GetLocRequests(req *LocRequestsOptions, srv LocalWorkerControlService_GetLocRequestsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetLocRequests not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) SetLocActuals(srv LocalWorkerControlService_SetLocActualsServer) error {
	return status.Errorf(codes.Unimplemented, "method SetLocActuals not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) SetSensorActuals(srv LocalWorkerControlService_SetSensorActualsServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSensorActuals not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) GetOutputRequests(req *OutputRequestsOptions, srv LocalWorkerControlService_GetOutputRequestsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetOutputRequests not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) SetOutputActuals(srv LocalWorkerControlService_SetOutputActualsServer) error {
	return status.Errorf(codes.Unimplemented, "method SetOutputActuals not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) GetSwitchRequests(req *SwitchRequestsOptions, srv LocalWorkerControlService_GetSwitchRequestsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSwitchRequests not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) SetSwitchActuals(srv LocalWorkerControlService_SetSwitchActualsServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSwitchActuals not implemented")
}
func (*UnimplementedLocalWorkerControlServiceServer) GetClock(req *Empty, srv LocalWorkerControlService_GetClockServer) error {
	return status.Errorf(codes.Unimplemented, "method GetClock not implemented")
}

func RegisterLocalWorkerControlServiceServer(s *grpc.Server, srv LocalWorkerControlServiceServer) {
	s.RegisterService(&_LocalWorkerControlService_serviceDesc, srv)
}

func _LocalWorkerControlService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LocalWorkerInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LocalWorkerControlServiceServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/binkynet.v1.LocalWorkerControlService/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LocalWorkerControlServiceServer).Ping(ctx, req.(*LocalWorkerInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _LocalWorkerControlService_GetDiscoverRequests_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LocalWorkerInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LocalWorkerControlServiceServer).GetDiscoverRequests(m, &localWorkerControlServiceGetDiscoverRequestsServer{stream})
}

type LocalWorkerControlService_GetDiscoverRequestsServer interface {
	Send(*DiscoverRequest) error
	grpc.ServerStream
}

type localWorkerControlServiceGetDiscoverRequestsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceGetDiscoverRequestsServer) Send(m *DiscoverRequest) error {
	return x.ServerStream.SendMsg(m)
}

func _LocalWorkerControlService_SetDiscoverResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DiscoverResult)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LocalWorkerControlServiceServer).SetDiscoverResult(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/binkynet.v1.LocalWorkerControlService/SetDiscoverResult",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LocalWorkerControlServiceServer).SetDiscoverResult(ctx, req.(*DiscoverResult))
	}
	return interceptor(ctx, in, info, handler)
}

func _LocalWorkerControlService_GetPowerRequests_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PowerRequestsOptions)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LocalWorkerControlServiceServer).GetPowerRequests(m, &localWorkerControlServiceGetPowerRequestsServer{stream})
}

type LocalWorkerControlService_GetPowerRequestsServer interface {
	Send(*PowerState) error
	grpc.ServerStream
}

type localWorkerControlServiceGetPowerRequestsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceGetPowerRequestsServer) Send(m *PowerState) error {
	return x.ServerStream.SendMsg(m)
}

func _LocalWorkerControlService_SetPowerActuals_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(LocalWorkerControlServiceServer).SetPowerActuals(&localWorkerControlServiceSetPowerActualsServer{stream})
}

type LocalWorkerControlService_SetPowerActualsServer interface {
	SendAndClose(*Empty) error
	Recv() (*PowerState, error)
	grpc.ServerStream
}

type localWorkerControlServiceSetPowerActualsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceSetPowerActualsServer) SendAndClose(m *Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetPowerActualsServer) Recv() (*PowerState, error) {
	m := new(PowerState)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _LocalWorkerControlService_GetLocRequests_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LocRequestsOptions)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LocalWorkerControlServiceServer).GetLocRequests(m, &localWorkerControlServiceGetLocRequestsServer{stream})
}

type LocalWorkerControlService_GetLocRequestsServer interface {
	Send(*Loc) error
	grpc.ServerStream
}

type localWorkerControlServiceGetLocRequestsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceGetLocRequestsServer) Send(m *Loc) error {
	return x.ServerStream.SendMsg(m)
}

func _LocalWorkerControlService_SetLocActuals_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(LocalWorkerControlServiceServer).SetLocActuals(&localWorkerControlServiceSetLocActualsServer{stream})
}

type LocalWorkerControlService_SetLocActualsServer interface {
	SendAndClose(*Empty) error
	Recv() (*Loc, error)
	grpc.ServerStream
}

type localWorkerControlServiceSetLocActualsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceSetLocActualsServer) SendAndClose(m *Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetLocActualsServer) Recv() (*Loc, error) {
	m := new(Loc)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _LocalWorkerControlService_SetSensorActuals_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(LocalWorkerControlServiceServer).SetSensorActuals(&localWorkerControlServiceSetSensorActualsServer{stream})
}

type LocalWorkerControlService_SetSensorActualsServer interface {
	SendAndClose(*Empty) error
	Recv() (*Sensor, error)
	grpc.ServerStream
}

type localWorkerControlServiceSetSensorActualsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceSetSensorActualsServer) SendAndClose(m *Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetSensorActualsServer) Recv() (*Sensor, error) {
	m := new(Sensor)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _LocalWorkerControlService_GetOutputRequests_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OutputRequestsOptions)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LocalWorkerControlServiceServer).GetOutputRequests(m, &localWorkerControlServiceGetOutputRequestsServer{stream})
}

type LocalWorkerControlService_GetOutputRequestsServer interface {
	Send(*Output) error
	grpc.ServerStream
}

type localWorkerControlServiceGetOutputRequestsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceGetOutputRequestsServer) Send(m *Output) error {
	return x.ServerStream.SendMsg(m)
}

func _LocalWorkerControlService_SetOutputActuals_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(LocalWorkerControlServiceServer).SetOutputActuals(&localWorkerControlServiceSetOutputActualsServer{stream})
}

type LocalWorkerControlService_SetOutputActualsServer interface {
	SendAndClose(*Empty) error
	Recv() (*Output, error)
	grpc.ServerStream
}

type localWorkerControlServiceSetOutputActualsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceSetOutputActualsServer) SendAndClose(m *Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetOutputActualsServer) Recv() (*Output, error) {
	m := new(Output)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _LocalWorkerControlService_GetSwitchRequests_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SwitchRequestsOptions)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LocalWorkerControlServiceServer).GetSwitchRequests(m, &localWorkerControlServiceGetSwitchRequestsServer{stream})
}

type LocalWorkerControlService_GetSwitchRequestsServer interface {
	Send(*Switch) error
	grpc.ServerStream
}

type localWorkerControlServiceGetSwitchRequestsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceGetSwitchRequestsServer) Send(m *Switch) error {
	return x.ServerStream.SendMsg(m)
}

func _LocalWorkerControlService_SetSwitchActuals_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(LocalWorkerControlServiceServer).SetSwitchActuals(&localWorkerControlServiceSetSwitchActualsServer{stream})
}

type LocalWorkerControlService_SetSwitchActualsServer interface {
	SendAndClose(*Empty) error
	Recv() (*Switch, error)
	grpc.ServerStream
}

type localWorkerControlServiceSetSwitchActualsServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceSetSwitchActualsServer) SendAndClose(m *Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *localWorkerControlServiceSetSwitchActualsServer) Recv() (*Switch, error) {
	m := new(Switch)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _LocalWorkerControlService_GetClock_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LocalWorkerControlServiceServer).GetClock(m, &localWorkerControlServiceGetClockServer{stream})
}

type LocalWorkerControlService_GetClockServer interface {
	Send(*Clock) error
	grpc.ServerStream
}

type localWorkerControlServiceGetClockServer struct {
	grpc.ServerStream
}

func (x *localWorkerControlServiceGetClockServer) Send(m *Clock) error {
	return x.ServerStream.SendMsg(m)
}

var _LocalWorkerControlService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "binkynet.v1.LocalWorkerControlService",
	HandlerType: (*LocalWorkerControlServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _LocalWorkerControlService_Ping_Handler,
		},
		{
			MethodName: "SetDiscoverResult",
			Handler:    _LocalWorkerControlService_SetDiscoverResult_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetDiscoverRequests",
			Handler:       _LocalWorkerControlService_GetDiscoverRequests_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetPowerRequests",
			Handler:       _LocalWorkerControlService_GetPowerRequests_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetPowerActuals",
			Handler:       _LocalWorkerControlService_SetPowerActuals_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GetLocRequests",
			Handler:       _LocalWorkerControlService_GetLocRequests_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetLocActuals",
			Handler:       _LocalWorkerControlService_SetLocActuals_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SetSensorActuals",
			Handler:       _LocalWorkerControlService_SetSensorActuals_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GetOutputRequests",
			Handler:       _LocalWorkerControlService_GetOutputRequests_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetOutputActuals",
			Handler:       _LocalWorkerControlService_SetOutputActuals_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GetSwitchRequests",
			Handler:       _LocalWorkerControlService_GetSwitchRequests_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSwitchActuals",
			Handler:       _LocalWorkerControlService_SetSwitchActuals_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GetClock",
			Handler:       _LocalWorkerControlService_GetClock_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "localworker.proto",
}

func (m *DiscoverRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DiscoverRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DiscoverRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *DiscoverResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DiscoverResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DiscoverResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintLocalworker(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintLocalworker(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintLocalworker(dAtA []byte, offset int, v uint64) int {
	offset -= sovLocalworker(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DiscoverRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DiscoverResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovLocalworker(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovLocalworker(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovLocalworker(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLocalworker(x uint64) (n int) {
	return sovLocalworker(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DiscoverRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLocalworker
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DiscoverRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DiscoverRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipLocalworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLocalworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLocalworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DiscoverResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLocalworker
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DiscoverResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DiscoverResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLocalworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLocalworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLocalworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLocalworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLocalworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLocalworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLocalworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLocalworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLocalworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipLocalworker(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowLocalworker
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowLocalworker
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowLocalworker
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthLocalworker
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupLocalworker
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthLocalworker
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthLocalworker        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLocalworker          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLocalworker = fmt.Errorf("proto: unexpected end of group")
)