// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.19.4
// source: sni.proto

package sni

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// DevicesClient is the client API for Devices service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DevicesClient interface {
	// detect and list devices currently connected to the system:
	ListDevices(ctx context.Context, in *DevicesRequest, opts ...grpc.CallOption) (*DevicesResponse, error)
}

type devicesClient struct {
	cc grpc.ClientConnInterface
}

func NewDevicesClient(cc grpc.ClientConnInterface) DevicesClient {
	return &devicesClient{cc}
}

func (c *devicesClient) ListDevices(ctx context.Context, in *DevicesRequest, opts ...grpc.CallOption) (*DevicesResponse, error) {
	out := new(DevicesResponse)
	err := c.cc.Invoke(ctx, "/Devices/ListDevices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DevicesServer is the server API for Devices service.
// All implementations must embed UnimplementedDevicesServer
// for forward compatibility
type DevicesServer interface {
	// detect and list devices currently connected to the system:
	ListDevices(context.Context, *DevicesRequest) (*DevicesResponse, error)
	mustEmbedUnimplementedDevicesServer()
}

// UnimplementedDevicesServer must be embedded to have forward compatible implementations.
type UnimplementedDevicesServer struct {
}

func (UnimplementedDevicesServer) ListDevices(context.Context, *DevicesRequest) (*DevicesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListDevices not implemented")
}
func (UnimplementedDevicesServer) mustEmbedUnimplementedDevicesServer() {}

// UnsafeDevicesServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DevicesServer will
// result in compilation errors.
type UnsafeDevicesServer interface {
	mustEmbedUnimplementedDevicesServer()
}

func RegisterDevicesServer(s grpc.ServiceRegistrar, srv DevicesServer) {
	s.RegisterService(&Devices_ServiceDesc, srv)
}

func _Devices_ListDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DevicesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DevicesServer).ListDevices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Devices/ListDevices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DevicesServer).ListDevices(ctx, req.(*DevicesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Devices_ServiceDesc is the grpc.ServiceDesc for Devices service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Devices_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "Devices",
	HandlerType: (*DevicesServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListDevices",
			Handler:    _Devices_ListDevices_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "sni.proto",
}

// DeviceControlClient is the client API for DeviceControl service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DeviceControlClient interface {
	// only available if DeviceCapability ResetSystem is present
	ResetSystem(ctx context.Context, in *ResetSystemRequest, opts ...grpc.CallOption) (*ResetSystemResponse, error)
	// only available if DeviceCapability ResetToMenu is present
	ResetToMenu(ctx context.Context, in *ResetToMenuRequest, opts ...grpc.CallOption) (*ResetToMenuResponse, error)
	// only available if DeviceCapability PauseUnpauseEmulation is present
	PauseUnpauseEmulation(ctx context.Context, in *PauseEmulationRequest, opts ...grpc.CallOption) (*PauseEmulationResponse, error)
	// only available if DeviceCapability PauseToggleEmulation is present
	PauseToggleEmulation(ctx context.Context, in *PauseToggleEmulationRequest, opts ...grpc.CallOption) (*PauseToggleEmulationResponse, error)
}

type deviceControlClient struct {
	cc grpc.ClientConnInterface
}

func NewDeviceControlClient(cc grpc.ClientConnInterface) DeviceControlClient {
	return &deviceControlClient{cc}
}

func (c *deviceControlClient) ResetSystem(ctx context.Context, in *ResetSystemRequest, opts ...grpc.CallOption) (*ResetSystemResponse, error) {
	out := new(ResetSystemResponse)
	err := c.cc.Invoke(ctx, "/DeviceControl/ResetSystem", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceControlClient) ResetToMenu(ctx context.Context, in *ResetToMenuRequest, opts ...grpc.CallOption) (*ResetToMenuResponse, error) {
	out := new(ResetToMenuResponse)
	err := c.cc.Invoke(ctx, "/DeviceControl/ResetToMenu", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceControlClient) PauseUnpauseEmulation(ctx context.Context, in *PauseEmulationRequest, opts ...grpc.CallOption) (*PauseEmulationResponse, error) {
	out := new(PauseEmulationResponse)
	err := c.cc.Invoke(ctx, "/DeviceControl/PauseUnpauseEmulation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceControlClient) PauseToggleEmulation(ctx context.Context, in *PauseToggleEmulationRequest, opts ...grpc.CallOption) (*PauseToggleEmulationResponse, error) {
	out := new(PauseToggleEmulationResponse)
	err := c.cc.Invoke(ctx, "/DeviceControl/PauseToggleEmulation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DeviceControlServer is the server API for DeviceControl service.
// All implementations must embed UnimplementedDeviceControlServer
// for forward compatibility
type DeviceControlServer interface {
	// only available if DeviceCapability ResetSystem is present
	ResetSystem(context.Context, *ResetSystemRequest) (*ResetSystemResponse, error)
	// only available if DeviceCapability ResetToMenu is present
	ResetToMenu(context.Context, *ResetToMenuRequest) (*ResetToMenuResponse, error)
	// only available if DeviceCapability PauseUnpauseEmulation is present
	PauseUnpauseEmulation(context.Context, *PauseEmulationRequest) (*PauseEmulationResponse, error)
	// only available if DeviceCapability PauseToggleEmulation is present
	PauseToggleEmulation(context.Context, *PauseToggleEmulationRequest) (*PauseToggleEmulationResponse, error)
	mustEmbedUnimplementedDeviceControlServer()
}

// UnimplementedDeviceControlServer must be embedded to have forward compatible implementations.
type UnimplementedDeviceControlServer struct {
}

func (UnimplementedDeviceControlServer) ResetSystem(context.Context, *ResetSystemRequest) (*ResetSystemResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetSystem not implemented")
}
func (UnimplementedDeviceControlServer) ResetToMenu(context.Context, *ResetToMenuRequest) (*ResetToMenuResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetToMenu not implemented")
}
func (UnimplementedDeviceControlServer) PauseUnpauseEmulation(context.Context, *PauseEmulationRequest) (*PauseEmulationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PauseUnpauseEmulation not implemented")
}
func (UnimplementedDeviceControlServer) PauseToggleEmulation(context.Context, *PauseToggleEmulationRequest) (*PauseToggleEmulationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PauseToggleEmulation not implemented")
}
func (UnimplementedDeviceControlServer) mustEmbedUnimplementedDeviceControlServer() {}

// UnsafeDeviceControlServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DeviceControlServer will
// result in compilation errors.
type UnsafeDeviceControlServer interface {
	mustEmbedUnimplementedDeviceControlServer()
}

func RegisterDeviceControlServer(s grpc.ServiceRegistrar, srv DeviceControlServer) {
	s.RegisterService(&DeviceControl_ServiceDesc, srv)
}

func _DeviceControl_ResetSystem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResetSystemRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceControlServer).ResetSystem(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceControl/ResetSystem",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceControlServer).ResetSystem(ctx, req.(*ResetSystemRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceControl_ResetToMenu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResetToMenuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceControlServer).ResetToMenu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceControl/ResetToMenu",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceControlServer).ResetToMenu(ctx, req.(*ResetToMenuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceControl_PauseUnpauseEmulation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PauseEmulationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceControlServer).PauseUnpauseEmulation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceControl/PauseUnpauseEmulation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceControlServer).PauseUnpauseEmulation(ctx, req.(*PauseEmulationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceControl_PauseToggleEmulation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PauseToggleEmulationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceControlServer).PauseToggleEmulation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceControl/PauseToggleEmulation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceControlServer).PauseToggleEmulation(ctx, req.(*PauseToggleEmulationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DeviceControl_ServiceDesc is the grpc.ServiceDesc for DeviceControl service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DeviceControl_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "DeviceControl",
	HandlerType: (*DeviceControlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ResetSystem",
			Handler:    _DeviceControl_ResetSystem_Handler,
		},
		{
			MethodName: "ResetToMenu",
			Handler:    _DeviceControl_ResetToMenu_Handler,
		},
		{
			MethodName: "PauseUnpauseEmulation",
			Handler:    _DeviceControl_PauseUnpauseEmulation_Handler,
		},
		{
			MethodName: "PauseToggleEmulation",
			Handler:    _DeviceControl_PauseToggleEmulation_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "sni.proto",
}

// DeviceMemoryClient is the client API for DeviceMemory service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DeviceMemoryClient interface {
	// detect the current memory mapping for the given device by reading 00:FFB0 header:
	MappingDetect(ctx context.Context, in *DetectMemoryMappingRequest, opts ...grpc.CallOption) (*DetectMemoryMappingResponse, error)
	// read a single memory segment with a given size from the given device:
	SingleRead(ctx context.Context, in *SingleReadMemoryRequest, opts ...grpc.CallOption) (*SingleReadMemoryResponse, error)
	// write a single memory segment with given data to the given device:
	SingleWrite(ctx context.Context, in *SingleWriteMemoryRequest, opts ...grpc.CallOption) (*SingleWriteMemoryResponse, error)
	// read multiple memory segments with given sizes from the given device:
	MultiRead(ctx context.Context, in *MultiReadMemoryRequest, opts ...grpc.CallOption) (*MultiReadMemoryResponse, error)
	// write multiple memory segments with given data to the given device:
	MultiWrite(ctx context.Context, in *MultiWriteMemoryRequest, opts ...grpc.CallOption) (*MultiWriteMemoryResponse, error)
	// stream read multiple memory segments with given sizes from the given device:
	StreamRead(ctx context.Context, opts ...grpc.CallOption) (DeviceMemory_StreamReadClient, error)
	// stream write multiple memory segments with given data to the given device:
	StreamWrite(ctx context.Context, opts ...grpc.CallOption) (DeviceMemory_StreamWriteClient, error)
}

type deviceMemoryClient struct {
	cc grpc.ClientConnInterface
}

func NewDeviceMemoryClient(cc grpc.ClientConnInterface) DeviceMemoryClient {
	return &deviceMemoryClient{cc}
}

func (c *deviceMemoryClient) MappingDetect(ctx context.Context, in *DetectMemoryMappingRequest, opts ...grpc.CallOption) (*DetectMemoryMappingResponse, error) {
	out := new(DetectMemoryMappingResponse)
	err := c.cc.Invoke(ctx, "/DeviceMemory/MappingDetect", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceMemoryClient) SingleRead(ctx context.Context, in *SingleReadMemoryRequest, opts ...grpc.CallOption) (*SingleReadMemoryResponse, error) {
	out := new(SingleReadMemoryResponse)
	err := c.cc.Invoke(ctx, "/DeviceMemory/SingleRead", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceMemoryClient) SingleWrite(ctx context.Context, in *SingleWriteMemoryRequest, opts ...grpc.CallOption) (*SingleWriteMemoryResponse, error) {
	out := new(SingleWriteMemoryResponse)
	err := c.cc.Invoke(ctx, "/DeviceMemory/SingleWrite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceMemoryClient) MultiRead(ctx context.Context, in *MultiReadMemoryRequest, opts ...grpc.CallOption) (*MultiReadMemoryResponse, error) {
	out := new(MultiReadMemoryResponse)
	err := c.cc.Invoke(ctx, "/DeviceMemory/MultiRead", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceMemoryClient) MultiWrite(ctx context.Context, in *MultiWriteMemoryRequest, opts ...grpc.CallOption) (*MultiWriteMemoryResponse, error) {
	out := new(MultiWriteMemoryResponse)
	err := c.cc.Invoke(ctx, "/DeviceMemory/MultiWrite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceMemoryClient) StreamRead(ctx context.Context, opts ...grpc.CallOption) (DeviceMemory_StreamReadClient, error) {
	stream, err := c.cc.NewStream(ctx, &DeviceMemory_ServiceDesc.Streams[0], "/DeviceMemory/StreamRead", opts...)
	if err != nil {
		return nil, err
	}
	x := &deviceMemoryStreamReadClient{stream}
	return x, nil
}

type DeviceMemory_StreamReadClient interface {
	Send(*MultiReadMemoryRequest) error
	Recv() (*MultiReadMemoryResponse, error)
	grpc.ClientStream
}

type deviceMemoryStreamReadClient struct {
	grpc.ClientStream
}

func (x *deviceMemoryStreamReadClient) Send(m *MultiReadMemoryRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *deviceMemoryClient) StreamWrite(ctx context.Context, opts ...grpc.CallOption) (DeviceMemory_StreamWriteClient, error) {
	stream, err := c.cc.NewStream(ctx, &DeviceMemory_ServiceDesc.Streams[1], "/DeviceMemory/StreamWrite", opts...)
	if err != nil {
		return nil, err
	}
	x := &deviceMemoryStreamWriteClient{stream}
	return x, nil
}

type DeviceMemory_StreamWriteClient interface {
	Send(*MultiWriteMemoryRequest) error
	Recv() (*MultiWriteMemoryResponse, error)
	grpc.ClientStream
}

type deviceMemoryStreamWriteClient struct {
	grpc.ClientStream
}

func (x *deviceMemoryStreamWriteClient) Send(m *MultiWriteMemoryRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

// DeviceMemoryServer is the server API for DeviceMemory service.
// All implementations must embed UnimplementedDeviceMemoryServer
// for forward compatibility
type DeviceMemoryServer interface {
	// detect the current memory mapping for the given device by reading 00:FFB0 header:
	MappingDetect(context.Context, *DetectMemoryMappingRequest) (*DetectMemoryMappingResponse, error)
	// read a single memory segment with a given size from the given device:
	SingleRead(context.Context, *SingleReadMemoryRequest) (*SingleReadMemoryResponse, error)
	// write a single memory segment with given data to the given device:
	SingleWrite(context.Context, *SingleWriteMemoryRequest) (*SingleWriteMemoryResponse, error)
	// read multiple memory segments with given sizes from the given device:
	MultiRead(context.Context, *MultiReadMemoryRequest) (*MultiReadMemoryResponse, error)
	// write multiple memory segments with given data to the given device:
	MultiWrite(context.Context, *MultiWriteMemoryRequest) (*MultiWriteMemoryResponse, error)
	// stream read multiple memory segments with given sizes from the given device:
	StreamRead(DeviceMemory_StreamReadServer) error
	// stream write multiple memory segments with given data to the given device:
	StreamWrite(DeviceMemory_StreamWriteServer) error
	mustEmbedUnimplementedDeviceMemoryServer()
}

// UnimplementedDeviceMemoryServer must be embedded to have forward compatible implementations.
type UnimplementedDeviceMemoryServer struct {
}

func (UnimplementedDeviceMemoryServer) MappingDetect(context.Context, *DetectMemoryMappingRequest) (*DetectMemoryMappingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MappingDetect not implemented")
}
func (UnimplementedDeviceMemoryServer) SingleRead(context.Context, *SingleReadMemoryRequest) (*SingleReadMemoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SingleRead not implemented")
}
func (UnimplementedDeviceMemoryServer) SingleWrite(context.Context, *SingleWriteMemoryRequest) (*SingleWriteMemoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SingleWrite not implemented")
}
func (UnimplementedDeviceMemoryServer) MultiRead(context.Context, *MultiReadMemoryRequest) (*MultiReadMemoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MultiRead not implemented")
}
func (UnimplementedDeviceMemoryServer) MultiWrite(context.Context, *MultiWriteMemoryRequest) (*MultiWriteMemoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MultiWrite not implemented")
}
func (UnimplementedDeviceMemoryServer) StreamRead(DeviceMemory_StreamReadServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamRead not implemented")
}
func (UnimplementedDeviceMemoryServer) StreamWrite(DeviceMemory_StreamWriteServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamWrite not implemented")
}
func (UnimplementedDeviceMemoryServer) mustEmbedUnimplementedDeviceMemoryServer() {}

// UnsafeDeviceMemoryServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DeviceMemoryServer will
// result in compilation errors.
type UnsafeDeviceMemoryServer interface {
	mustEmbedUnimplementedDeviceMemoryServer()
}

func RegisterDeviceMemoryServer(s grpc.ServiceRegistrar, srv DeviceMemoryServer) {
	s.RegisterService(&DeviceMemory_ServiceDesc, srv)
}

func _DeviceMemory_MappingDetect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DetectMemoryMappingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceMemoryServer).MappingDetect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceMemory/MappingDetect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceMemoryServer).MappingDetect(ctx, req.(*DetectMemoryMappingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceMemory_SingleRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleReadMemoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceMemoryServer).SingleRead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceMemory/SingleRead",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceMemoryServer).SingleRead(ctx, req.(*SingleReadMemoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceMemory_SingleWrite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SingleWriteMemoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceMemoryServer).SingleWrite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceMemory/SingleWrite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceMemoryServer).SingleWrite(ctx, req.(*SingleWriteMemoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceMemory_MultiRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MultiReadMemoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceMemoryServer).MultiRead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceMemory/MultiRead",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceMemoryServer).MultiRead(ctx, req.(*MultiReadMemoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceMemory_MultiWrite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MultiWriteMemoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceMemoryServer).MultiWrite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceMemory/MultiWrite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceMemoryServer).MultiWrite(ctx, req.(*MultiWriteMemoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceMemory_StreamRead_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DeviceMemoryServer).StreamRead(&deviceMemoryStreamReadServer{stream})
}

type DeviceMemory_StreamReadServer interface {
	Send(*MultiReadMemoryResponse) error
	Recv() (*MultiReadMemoryRequest, error)
	grpc.ServerStream
}

type deviceMemoryStreamReadServer struct {
	grpc.ServerStream
}

func (x *deviceMemoryStreamReadServer) Send(m *MultiReadMemoryResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _DeviceMemory_StreamWrite_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DeviceMemoryServer).StreamWrite(&deviceMemoryStreamWriteServer{stream})
}

type DeviceMemory_StreamWriteServer interface {
	Send(*MultiWriteMemoryResponse) error
	Recv() (*MultiWriteMemoryRequest, error)
	grpc.ServerStream
}

type deviceMemoryStreamWriteServer struct {
	grpc.ServerStream
}

func (x *deviceMemoryStreamWriteServer) Send(m *MultiWriteMemoryResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

// DeviceMemory_ServiceDesc is the grpc.ServiceDesc for DeviceMemory service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DeviceMemory_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "DeviceMemory",
	HandlerType: (*DeviceMemoryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "MappingDetect",
			Handler:    _DeviceMemory_MappingDetect_Handler,
		},
		{
			MethodName: "SingleRead",
			Handler:    _DeviceMemory_SingleRead_Handler,
		},
		{
			MethodName: "SingleWrite",
			Handler:    _DeviceMemory_SingleWrite_Handler,
		},
		{
			MethodName: "MultiRead",
			Handler:    _DeviceMemory_MultiRead_Handler,
		},
		{
			MethodName: "MultiWrite",
			Handler:    _DeviceMemory_MultiWrite_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamRead",
			Handler:       _DeviceMemory_StreamRead_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "StreamWrite",
			Handler:       _DeviceMemory_StreamWrite_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "sni.proto",
}

// DeviceFilesystemClient is the client API for DeviceFilesystem service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DeviceFilesystemClient interface {
	ReadDirectory(ctx context.Context, in *ReadDirectoryRequest, opts ...grpc.CallOption) (*ReadDirectoryResponse, error)
	MakeDirectory(ctx context.Context, in *MakeDirectoryRequest, opts ...grpc.CallOption) (*MakeDirectoryResponse, error)
	RemoveFile(ctx context.Context, in *RemoveFileRequest, opts ...grpc.CallOption) (*RemoveFileResponse, error)
	RenameFile(ctx context.Context, in *RenameFileRequest, opts ...grpc.CallOption) (*RenameFileResponse, error)
	PutFile(ctx context.Context, in *PutFileRequest, opts ...grpc.CallOption) (*PutFileResponse, error)
	GetFile(ctx context.Context, in *GetFileRequest, opts ...grpc.CallOption) (*GetFileResponse, error)
	BootFile(ctx context.Context, in *BootFileRequest, opts ...grpc.CallOption) (*BootFileResponse, error)
}

type deviceFilesystemClient struct {
	cc grpc.ClientConnInterface
}

func NewDeviceFilesystemClient(cc grpc.ClientConnInterface) DeviceFilesystemClient {
	return &deviceFilesystemClient{cc}
}

func (c *deviceFilesystemClient) ReadDirectory(ctx context.Context, in *ReadDirectoryRequest, opts ...grpc.CallOption) (*ReadDirectoryResponse, error) {
	out := new(ReadDirectoryResponse)
	err := c.cc.Invoke(ctx, "/DeviceFilesystem/ReadDirectory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceFilesystemClient) MakeDirectory(ctx context.Context, in *MakeDirectoryRequest, opts ...grpc.CallOption) (*MakeDirectoryResponse, error) {
	out := new(MakeDirectoryResponse)
	err := c.cc.Invoke(ctx, "/DeviceFilesystem/MakeDirectory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceFilesystemClient) RemoveFile(ctx context.Context, in *RemoveFileRequest, opts ...grpc.CallOption) (*RemoveFileResponse, error) {
	out := new(RemoveFileResponse)
	err := c.cc.Invoke(ctx, "/DeviceFilesystem/RemoveFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceFilesystemClient) RenameFile(ctx context.Context, in *RenameFileRequest, opts ...grpc.CallOption) (*RenameFileResponse, error) {
	out := new(RenameFileResponse)
	err := c.cc.Invoke(ctx, "/DeviceFilesystem/RenameFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceFilesystemClient) PutFile(ctx context.Context, in *PutFileRequest, opts ...grpc.CallOption) (*PutFileResponse, error) {
	out := new(PutFileResponse)
	err := c.cc.Invoke(ctx, "/DeviceFilesystem/PutFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceFilesystemClient) GetFile(ctx context.Context, in *GetFileRequest, opts ...grpc.CallOption) (*GetFileResponse, error) {
	out := new(GetFileResponse)
	err := c.cc.Invoke(ctx, "/DeviceFilesystem/GetFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceFilesystemClient) BootFile(ctx context.Context, in *BootFileRequest, opts ...grpc.CallOption) (*BootFileResponse, error) {
	out := new(BootFileResponse)
	err := c.cc.Invoke(ctx, "/DeviceFilesystem/BootFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DeviceFilesystemServer is the server API for DeviceFilesystem service.
// All implementations must embed UnimplementedDeviceFilesystemServer
// for forward compatibility
type DeviceFilesystemServer interface {
	ReadDirectory(context.Context, *ReadDirectoryRequest) (*ReadDirectoryResponse, error)
	MakeDirectory(context.Context, *MakeDirectoryRequest) (*MakeDirectoryResponse, error)
	RemoveFile(context.Context, *RemoveFileRequest) (*RemoveFileResponse, error)
	RenameFile(context.Context, *RenameFileRequest) (*RenameFileResponse, error)
	PutFile(context.Context, *PutFileRequest) (*PutFileResponse, error)
	GetFile(context.Context, *GetFileRequest) (*GetFileResponse, error)
	BootFile(context.Context, *BootFileRequest) (*BootFileResponse, error)
	mustEmbedUnimplementedDeviceFilesystemServer()
}

// UnimplementedDeviceFilesystemServer must be embedded to have forward compatible implementations.
type UnimplementedDeviceFilesystemServer struct {
}

func (UnimplementedDeviceFilesystemServer) ReadDirectory(context.Context, *ReadDirectoryRequest) (*ReadDirectoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReadDirectory not implemented")
}
func (UnimplementedDeviceFilesystemServer) MakeDirectory(context.Context, *MakeDirectoryRequest) (*MakeDirectoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MakeDirectory not implemented")
}
func (UnimplementedDeviceFilesystemServer) RemoveFile(context.Context, *RemoveFileRequest) (*RemoveFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveFile not implemented")
}
func (UnimplementedDeviceFilesystemServer) RenameFile(context.Context, *RenameFileRequest) (*RenameFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenameFile not implemented")
}
func (UnimplementedDeviceFilesystemServer) PutFile(context.Context, *PutFileRequest) (*PutFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PutFile not implemented")
}
func (UnimplementedDeviceFilesystemServer) GetFile(context.Context, *GetFileRequest) (*GetFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFile not implemented")
}
func (UnimplementedDeviceFilesystemServer) BootFile(context.Context, *BootFileRequest) (*BootFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BootFile not implemented")
}
func (UnimplementedDeviceFilesystemServer) mustEmbedUnimplementedDeviceFilesystemServer() {}

// UnsafeDeviceFilesystemServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DeviceFilesystemServer will
// result in compilation errors.
type UnsafeDeviceFilesystemServer interface {
	mustEmbedUnimplementedDeviceFilesystemServer()
}

func RegisterDeviceFilesystemServer(s grpc.ServiceRegistrar, srv DeviceFilesystemServer) {
	s.RegisterService(&DeviceFilesystem_ServiceDesc, srv)
}

func _DeviceFilesystem_ReadDirectory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadDirectoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceFilesystemServer).ReadDirectory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceFilesystem/ReadDirectory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceFilesystemServer).ReadDirectory(ctx, req.(*ReadDirectoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceFilesystem_MakeDirectory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MakeDirectoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceFilesystemServer).MakeDirectory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceFilesystem/MakeDirectory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceFilesystemServer).MakeDirectory(ctx, req.(*MakeDirectoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceFilesystem_RemoveFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceFilesystemServer).RemoveFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceFilesystem/RemoveFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceFilesystemServer).RemoveFile(ctx, req.(*RemoveFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceFilesystem_RenameFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RenameFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceFilesystemServer).RenameFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceFilesystem/RenameFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceFilesystemServer).RenameFile(ctx, req.(*RenameFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceFilesystem_PutFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PutFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceFilesystemServer).PutFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceFilesystem/PutFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceFilesystemServer).PutFile(ctx, req.(*PutFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceFilesystem_GetFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceFilesystemServer).GetFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceFilesystem/GetFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceFilesystemServer).GetFile(ctx, req.(*GetFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceFilesystem_BootFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BootFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceFilesystemServer).BootFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceFilesystem/BootFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceFilesystemServer).BootFile(ctx, req.(*BootFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DeviceFilesystem_ServiceDesc is the grpc.ServiceDesc for DeviceFilesystem service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DeviceFilesystem_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "DeviceFilesystem",
	HandlerType: (*DeviceFilesystemServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ReadDirectory",
			Handler:    _DeviceFilesystem_ReadDirectory_Handler,
		},
		{
			MethodName: "MakeDirectory",
			Handler:    _DeviceFilesystem_MakeDirectory_Handler,
		},
		{
			MethodName: "RemoveFile",
			Handler:    _DeviceFilesystem_RemoveFile_Handler,
		},
		{
			MethodName: "RenameFile",
			Handler:    _DeviceFilesystem_RenameFile_Handler,
		},
		{
			MethodName: "PutFile",
			Handler:    _DeviceFilesystem_PutFile_Handler,
		},
		{
			MethodName: "GetFile",
			Handler:    _DeviceFilesystem_GetFile_Handler,
		},
		{
			MethodName: "BootFile",
			Handler:    _DeviceFilesystem_BootFile_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "sni.proto",
}

// DeviceInfoClient is the client API for DeviceInfo service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DeviceInfoClient interface {
	FetchFields(ctx context.Context, in *FieldsRequest, opts ...grpc.CallOption) (*FieldsResponse, error)
}

type deviceInfoClient struct {
	cc grpc.ClientConnInterface
}

func NewDeviceInfoClient(cc grpc.ClientConnInterface) DeviceInfoClient {
	return &deviceInfoClient{cc}
}

func (c *deviceInfoClient) FetchFields(ctx context.Context, in *FieldsRequest, opts ...grpc.CallOption) (*FieldsResponse, error) {
	out := new(FieldsResponse)
	err := c.cc.Invoke(ctx, "/DeviceInfo/FetchFields", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DeviceInfoServer is the server API for DeviceInfo service.
// All implementations must embed UnimplementedDeviceInfoServer
// for forward compatibility
type DeviceInfoServer interface {
	FetchFields(context.Context, *FieldsRequest) (*FieldsResponse, error)
	mustEmbedUnimplementedDeviceInfoServer()
}

// UnimplementedDeviceInfoServer must be embedded to have forward compatible implementations.
type UnimplementedDeviceInfoServer struct {
}

func (UnimplementedDeviceInfoServer) FetchFields(context.Context, *FieldsRequest) (*FieldsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FetchFields not implemented")
}
func (UnimplementedDeviceInfoServer) mustEmbedUnimplementedDeviceInfoServer() {}

// UnsafeDeviceInfoServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DeviceInfoServer will
// result in compilation errors.
type UnsafeDeviceInfoServer interface {
	mustEmbedUnimplementedDeviceInfoServer()
}

func RegisterDeviceInfoServer(s grpc.ServiceRegistrar, srv DeviceInfoServer) {
	s.RegisterService(&DeviceInfo_ServiceDesc, srv)
}

func _DeviceInfo_FetchFields_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FieldsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceInfoServer).FetchFields(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceInfo/FetchFields",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceInfoServer).FetchFields(ctx, req.(*FieldsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DeviceInfo_ServiceDesc is the grpc.ServiceDesc for DeviceInfo service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DeviceInfo_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "DeviceInfo",
	HandlerType: (*DeviceInfoServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "FetchFields",
			Handler:    _DeviceInfo_FetchFields_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "sni.proto",
}

// DeviceNWAClient is the client API for DeviceNWA service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DeviceNWAClient interface {
	NWACommand(ctx context.Context, in *NWACommandRequest, opts ...grpc.CallOption) (*NWACommandResponse, error)
}

type deviceNWAClient struct {
	cc grpc.ClientConnInterface
}

func NewDeviceNWAClient(cc grpc.ClientConnInterface) DeviceNWAClient {
	return &deviceNWAClient{cc}
}

func (c *deviceNWAClient) NWACommand(ctx context.Context, in *NWACommandRequest, opts ...grpc.CallOption) (*NWACommandResponse, error) {
	out := new(NWACommandResponse)
	err := c.cc.Invoke(ctx, "/DeviceNWA/NWACommand", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DeviceNWAServer is the server API for DeviceNWA service.
// All implementations must embed UnimplementedDeviceNWAServer
// for forward compatibility
type DeviceNWAServer interface {
	NWACommand(context.Context, *NWACommandRequest) (*NWACommandResponse, error)
	mustEmbedUnimplementedDeviceNWAServer()
}

// UnimplementedDeviceNWAServer must be embedded to have forward compatible implementations.
type UnimplementedDeviceNWAServer struct {
}

func (UnimplementedDeviceNWAServer) NWACommand(context.Context, *NWACommandRequest) (*NWACommandResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NWACommand not implemented")
}
func (UnimplementedDeviceNWAServer) mustEmbedUnimplementedDeviceNWAServer() {}

// UnsafeDeviceNWAServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DeviceNWAServer will
// result in compilation errors.
type UnsafeDeviceNWAServer interface {
	mustEmbedUnimplementedDeviceNWAServer()
}

func RegisterDeviceNWAServer(s grpc.ServiceRegistrar, srv DeviceNWAServer) {
	s.RegisterService(&DeviceNWA_ServiceDesc, srv)
}

func _DeviceNWA_NWACommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NWACommandRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceNWAServer).NWACommand(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/DeviceNWA/NWACommand",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceNWAServer).NWACommand(ctx, req.(*NWACommandRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DeviceNWA_ServiceDesc is the grpc.ServiceDesc for DeviceNWA service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DeviceNWA_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "DeviceNWA",
	HandlerType: (*DeviceNWAServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "NWACommand",
			Handler:    _DeviceNWA_NWACommand_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "sni.proto",
}
