// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pkg/apiclient/sensor/sensor.proto

package sensor

import (
	context "context"
	fmt "fmt"
	v1alpha1 "github.com/argoproj/argo-events/pkg/apis/events/v1alpha1"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	v11 "k8s.io/api/core/v1"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type ListSensorsRequest struct {
	Namespace            string          `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	ListOptions          *v1.ListOptions `protobuf:"bytes,2,opt,name=listOptions,proto3" json:"listOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ListSensorsRequest) Reset()         { *m = ListSensorsRequest{} }
func (m *ListSensorsRequest) String() string { return proto.CompactTextString(m) }
func (*ListSensorsRequest) ProtoMessage()    {}
func (*ListSensorsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{0}
}
func (m *ListSensorsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListSensorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListSensorsRequest.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 *ListSensorsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListSensorsRequest.Merge(m, src)
}
func (m *ListSensorsRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListSensorsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListSensorsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListSensorsRequest proto.InternalMessageInfo

func (m *ListSensorsRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ListSensorsRequest) GetListOptions() *v1.ListOptions {
	if m != nil {
		return m.ListOptions
	}
	return nil
}

type CreateSensorRequest struct {
	Namespace            string            `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Sensor               *v1alpha1.Sensor  `protobuf:"bytes,2,opt,name=sensor,proto3" json:"sensor,omitempty"`
	CreateOptions        *v1.CreateOptions `protobuf:"bytes,3,opt,name=createOptions,proto3" json:"createOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *CreateSensorRequest) Reset()         { *m = CreateSensorRequest{} }
func (m *CreateSensorRequest) String() string { return proto.CompactTextString(m) }
func (*CreateSensorRequest) ProtoMessage()    {}
func (*CreateSensorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{1}
}
func (m *CreateSensorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateSensorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateSensorRequest.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 *CreateSensorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateSensorRequest.Merge(m, src)
}
func (m *CreateSensorRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateSensorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateSensorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateSensorRequest proto.InternalMessageInfo

func (m *CreateSensorRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *CreateSensorRequest) GetSensor() *v1alpha1.Sensor {
	if m != nil {
		return m.Sensor
	}
	return nil
}

func (m *CreateSensorRequest) GetCreateOptions() *v1.CreateOptions {
	if m != nil {
		return m.CreateOptions
	}
	return nil
}

type GetSensorRequest struct {
	Name                 string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string         `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	GetOptions           *v1.GetOptions `protobuf:"bytes,3,opt,name=getOptions,proto3" json:"getOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *GetSensorRequest) Reset()         { *m = GetSensorRequest{} }
func (m *GetSensorRequest) String() string { return proto.CompactTextString(m) }
func (*GetSensorRequest) ProtoMessage()    {}
func (*GetSensorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{2}
}
func (m *GetSensorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetSensorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetSensorRequest.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 *GetSensorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetSensorRequest.Merge(m, src)
}
func (m *GetSensorRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetSensorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetSensorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetSensorRequest proto.InternalMessageInfo

func (m *GetSensorRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *GetSensorRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *GetSensorRequest) GetGetOptions() *v1.GetOptions {
	if m != nil {
		return m.GetOptions
	}
	return nil
}

type UpdateSensorRequest struct {
	Namespace            string           `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Name                 string           `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Sensor               *v1alpha1.Sensor `protobuf:"bytes,3,opt,name=sensor,proto3" json:"sensor,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *UpdateSensorRequest) Reset()         { *m = UpdateSensorRequest{} }
func (m *UpdateSensorRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateSensorRequest) ProtoMessage()    {}
func (*UpdateSensorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{3}
}
func (m *UpdateSensorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateSensorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateSensorRequest.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 *UpdateSensorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateSensorRequest.Merge(m, src)
}
func (m *UpdateSensorRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateSensorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateSensorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateSensorRequest proto.InternalMessageInfo

func (m *UpdateSensorRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *UpdateSensorRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UpdateSensorRequest) GetSensor() *v1alpha1.Sensor {
	if m != nil {
		return m.Sensor
	}
	return nil
}

type DeleteSensorRequest struct {
	Name                 string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string            `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	DeleteOptions        *v1.DeleteOptions `protobuf:"bytes,3,opt,name=deleteOptions,proto3" json:"deleteOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *DeleteSensorRequest) Reset()         { *m = DeleteSensorRequest{} }
func (m *DeleteSensorRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteSensorRequest) ProtoMessage()    {}
func (*DeleteSensorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{4}
}
func (m *DeleteSensorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteSensorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteSensorRequest.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 *DeleteSensorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteSensorRequest.Merge(m, src)
}
func (m *DeleteSensorRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeleteSensorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteSensorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteSensorRequest proto.InternalMessageInfo

func (m *DeleteSensorRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *DeleteSensorRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *DeleteSensorRequest) GetDeleteOptions() *v1.DeleteOptions {
	if m != nil {
		return m.DeleteOptions
	}
	return nil
}

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

func (m *DeleteSensorResponse) Reset()         { *m = DeleteSensorResponse{} }
func (m *DeleteSensorResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteSensorResponse) ProtoMessage()    {}
func (*DeleteSensorResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{5}
}
func (m *DeleteSensorResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteSensorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteSensorResponse.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 *DeleteSensorResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteSensorResponse.Merge(m, src)
}
func (m *DeleteSensorResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeleteSensorResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteSensorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteSensorResponse proto.InternalMessageInfo

type SensorsLogsRequest struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// optional - only return entries for this sensor name
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// optional - only return entries for this trigger
	TriggerName string `protobuf:"bytes,3,opt,name=triggerName,proto3" json:"triggerName,omitempty"`
	// option - only return entries where `msg` contains this regular expressions
	Grep                 string             `protobuf:"bytes,4,opt,name=grep,proto3" json:"grep,omitempty"`
	PodLogOptions        *v11.PodLogOptions `protobuf:"bytes,5,opt,name=podLogOptions,proto3" json:"podLogOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *SensorsLogsRequest) Reset()         { *m = SensorsLogsRequest{} }
func (m *SensorsLogsRequest) String() string { return proto.CompactTextString(m) }
func (*SensorsLogsRequest) ProtoMessage()    {}
func (*SensorsLogsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{6}
}
func (m *SensorsLogsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SensorsLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SensorsLogsRequest.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 *SensorsLogsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SensorsLogsRequest.Merge(m, src)
}
func (m *SensorsLogsRequest) XXX_Size() int {
	return m.Size()
}
func (m *SensorsLogsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SensorsLogsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SensorsLogsRequest proto.InternalMessageInfo

func (m *SensorsLogsRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *SensorsLogsRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SensorsLogsRequest) GetTriggerName() string {
	if m != nil {
		return m.TriggerName
	}
	return ""
}

func (m *SensorsLogsRequest) GetGrep() string {
	if m != nil {
		return m.Grep
	}
	return ""
}

func (m *SensorsLogsRequest) GetPodLogOptions() *v11.PodLogOptions {
	if m != nil {
		return m.PodLogOptions
	}
	return nil
}

// structured log entry
type LogEntry struct {
	Namespace  string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	SensorName string `protobuf:"bytes,2,opt,name=sensorName,proto3" json:"sensorName,omitempty"`
	// optional - any trigger name
	TriggerName string   `protobuf:"bytes,3,opt,name=triggerName,proto3" json:"triggerName,omitempty"`
	Level       string   `protobuf:"bytes,5,opt,name=level,proto3" json:"level,omitempty"`
	Time        *v1.Time `protobuf:"bytes,6,opt,name=time,proto3" json:"time,omitempty"`
	Msg         string   `protobuf:"bytes,7,opt,name=msg,proto3" json:"msg,omitempty"`
	// optional - trigger dependency name
	DependencyName string `protobuf:"bytes,8,opt,name=dependencyName,proto3" json:"dependencyName,omitempty"`
	// optional - Cloud Event context
	EventContext         string   `protobuf:"bytes,9,opt,name=eventContext,proto3" json:"eventContext,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LogEntry) Reset()         { *m = LogEntry{} }
func (m *LogEntry) String() string { return proto.CompactTextString(m) }
func (*LogEntry) ProtoMessage()    {}
func (*LogEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{7}
}
func (m *LogEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogEntry.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 *LogEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogEntry.Merge(m, src)
}
func (m *LogEntry) XXX_Size() int {
	return m.Size()
}
func (m *LogEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_LogEntry.DiscardUnknown(m)
}

var xxx_messageInfo_LogEntry proto.InternalMessageInfo

func (m *LogEntry) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *LogEntry) GetSensorName() string {
	if m != nil {
		return m.SensorName
	}
	return ""
}

func (m *LogEntry) GetTriggerName() string {
	if m != nil {
		return m.TriggerName
	}
	return ""
}

func (m *LogEntry) GetLevel() string {
	if m != nil {
		return m.Level
	}
	return ""
}

func (m *LogEntry) GetTime() *v1.Time {
	if m != nil {
		return m.Time
	}
	return nil
}

func (m *LogEntry) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *LogEntry) GetDependencyName() string {
	if m != nil {
		return m.DependencyName
	}
	return ""
}

func (m *LogEntry) GetEventContext() string {
	if m != nil {
		return m.EventContext
	}
	return ""
}

type SensorWatchEvent struct {
	Type                 string           `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Object               *v1alpha1.Sensor `protobuf:"bytes,2,opt,name=object,proto3" json:"object,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *SensorWatchEvent) Reset()         { *m = SensorWatchEvent{} }
func (m *SensorWatchEvent) String() string { return proto.CompactTextString(m) }
func (*SensorWatchEvent) ProtoMessage()    {}
func (*SensorWatchEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_78ba963e1c6b5b55, []int{8}
}
func (m *SensorWatchEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SensorWatchEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SensorWatchEvent.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 *SensorWatchEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SensorWatchEvent.Merge(m, src)
}
func (m *SensorWatchEvent) XXX_Size() int {
	return m.Size()
}
func (m *SensorWatchEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_SensorWatchEvent.DiscardUnknown(m)
}

var xxx_messageInfo_SensorWatchEvent proto.InternalMessageInfo

func (m *SensorWatchEvent) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *SensorWatchEvent) GetObject() *v1alpha1.Sensor {
	if m != nil {
		return m.Object
	}
	return nil
}

func init() {
	proto.RegisterType((*ListSensorsRequest)(nil), "sensor.ListSensorsRequest")
	proto.RegisterType((*CreateSensorRequest)(nil), "sensor.CreateSensorRequest")
	proto.RegisterType((*GetSensorRequest)(nil), "sensor.GetSensorRequest")
	proto.RegisterType((*UpdateSensorRequest)(nil), "sensor.UpdateSensorRequest")
	proto.RegisterType((*DeleteSensorRequest)(nil), "sensor.DeleteSensorRequest")
	proto.RegisterType((*DeleteSensorResponse)(nil), "sensor.DeleteSensorResponse")
	proto.RegisterType((*SensorsLogsRequest)(nil), "sensor.SensorsLogsRequest")
	proto.RegisterType((*LogEntry)(nil), "sensor.LogEntry")
	proto.RegisterType((*SensorWatchEvent)(nil), "sensor.SensorWatchEvent")
}

func init() { proto.RegisterFile("pkg/apiclient/sensor/sensor.proto", fileDescriptor_78ba963e1c6b5b55) }

var fileDescriptor_78ba963e1c6b5b55 = []byte{
	// 886 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x5f, 0x6f, 0x1c, 0x35,
	0x10, 0x97, 0x2f, 0x69, 0xda, 0x9b, 0xbb, 0xa0, 0xc8, 0xa9, 0xd0, 0xe9, 0x1a, 0xa2, 0xd4, 0xa0,
	0xb6, 0x44, 0xea, 0x6e, 0xae, 0x45, 0x02, 0xf1, 0x80, 0x10, 0x49, 0x14, 0x1e, 0x4e, 0xa5, 0xda,
	0x80, 0xa0, 0xbc, 0xa0, 0xcd, 0xde, 0xe0, 0x6c, 0xb3, 0xbb, 0x5e, 0x6c, 0xe7, 0x4a, 0x84, 0x90,
	0x10, 0x2f, 0x7c, 0x80, 0x02, 0x4f, 0x08, 0x09, 0xbe, 0x0b, 0x12, 0x4f, 0x08, 0x89, 0x2f, 0x80,
	0x22, 0x1e, 0xf8, 0x18, 0x95, 0xbd, 0xbe, 0xfd, 0x93, 0x5c, 0xdb, 0x6b, 0x73, 0x4f, 0x3b, 0x3b,
	0xf6, 0xcc, 0xfc, 0x7e, 0x33, 0x63, 0x8f, 0xe1, 0x7a, 0x7e, 0xc4, 0xfd, 0x30, 0x8f, 0xa3, 0x24,
	0xc6, 0x4c, 0xfb, 0x0a, 0x33, 0x25, 0xa4, 0xfb, 0x78, 0xb9, 0x14, 0x5a, 0xd0, 0xa5, 0xe2, 0xaf,
	0xbf, 0xc6, 0x85, 0xe0, 0x09, 0x9a, 0xdd, 0x7e, 0x98, 0x65, 0x42, 0x87, 0x3a, 0x16, 0x99, 0x2a,
	0x76, 0xf5, 0xdf, 0x3a, 0x7a, 0x47, 0x79, 0xb1, 0x30, 0xab, 0x69, 0x18, 0x1d, 0xc6, 0x19, 0xca,
	0x13, 0xdf, 0x39, 0x57, 0x7e, 0x8a, 0x3a, 0xf4, 0xc7, 0x03, 0x9f, 0x63, 0x86, 0x32, 0xd4, 0x38,
	0x72, 0x56, 0xac, 0xb2, 0xf2, 0x23, 0x21, 0x71, 0xda, 0x9e, 0x0f, 0x79, 0xac, 0x0f, 0x8f, 0x0f,
	0xbc, 0x48, 0xa4, 0x7e, 0x28, 0xb9, 0xc8, 0xa5, 0x78, 0x68, 0x85, 0xdb, 0x38, 0xc6, 0x4c, 0xab,
	0x2a, 0x8a, 0xfb, 0x1f, 0x0f, 0xc2, 0x24, 0x3f, 0x0c, 0xcf, 0x79, 0x62, 0x3f, 0x10, 0xa0, 0xc3,
	0x58, 0xe9, 0x7d, 0x4b, 0x48, 0x05, 0xf8, 0xd5, 0x31, 0x2a, 0x4d, 0xd7, 0xa0, 0x9d, 0x85, 0x29,
	0xaa, 0x3c, 0x8c, 0xb0, 0x47, 0x36, 0xc8, 0xad, 0x76, 0x50, 0x29, 0xe8, 0x3e, 0x74, 0x92, 0x58,
	0xe9, 0x8f, 0x72, 0xcb, 0xb6, 0xd7, 0xda, 0x20, 0xb7, 0x3a, 0x77, 0x06, 0x5e, 0x01, 0xdc, 0xab,
	0xd3, 0xf5, 0xf2, 0x23, 0x6e, 0x14, 0xca, 0x33, 0x74, 0xbd, 0xf1, 0xc0, 0x1b, 0x56, 0x86, 0x41,
	0xdd, 0x0b, 0xfb, 0x9f, 0xc0, 0xea, 0xb6, 0xc4, 0x50, 0x63, 0x81, 0x65, 0x36, 0x28, 0x9f, 0x81,
	0xab, 0x85, 0x43, 0xf1, 0xbe, 0x57, 0xa5, 0xc6, 0x9b, 0xa4, 0xc6, 0x0a, 0x5f, 0x14, 0xa9, 0xa8,
	0x10, 0xb9, 0xff, 0x49, 0x6a, 0x3c, 0x17, 0xd6, 0xf9, 0xa3, 0x0f, 0x60, 0x39, 0xb2, 0x70, 0x26,
	0x34, 0x17, 0x6c, 0x80, 0xbb, 0xb3, 0xd1, 0xdc, 0xae, 0x9b, 0x06, 0x4d, 0x4f, 0xec, 0x67, 0x02,
	0x2b, 0x7b, 0xa8, 0x9b, 0x3c, 0x29, 0x2c, 0x1a, 0x5a, 0x8e, 0xa2, 0x95, 0x9b, 0xdc, 0x5b, 0x67,
	0xb9, 0xdf, 0x07, 0xe0, 0xa8, 0x9b, 0xf0, 0xb6, 0x66, 0x83, 0xb7, 0x57, 0xda, 0x05, 0x35, 0x1f,
	0xec, 0x37, 0x02, 0xab, 0x9f, 0xe4, 0xa3, 0x17, 0xac, 0xc1, 0x04, 0x79, 0xab, 0x86, 0xbc, 0xaa,
	0xcb, 0xc2, 0x7c, 0xeb, 0xc2, 0x7e, 0x27, 0xb0, 0xba, 0x83, 0x09, 0x9e, 0xc5, 0xf8, 0xe2, 0xf9,
	0x7b, 0x00, 0xcb, 0x23, 0xeb, 0xe8, 0xa5, 0x2a, 0xbc, 0x53, 0x37, 0x0d, 0x9a, 0x9e, 0xd8, 0xab,
	0x70, 0xb5, 0x89, 0x51, 0xe5, 0x22, 0x53, 0xc8, 0xfe, 0x20, 0x40, 0xdd, 0x51, 0x1b, 0x0a, 0xae,
	0x5e, 0x3e, 0xbf, 0x1b, 0xd0, 0xd1, 0x32, 0xe6, 0x1c, 0xe5, 0x3d, 0xb3, 0xb4, 0x60, 0x97, 0xea,
	0x2a, 0x63, 0xc5, 0x25, 0xe6, 0xbd, 0xc5, 0xc2, 0xca, 0xc8, 0x74, 0x0f, 0x96, 0x73, 0x31, 0x1a,
	0x0a, 0x3e, 0x61, 0x7c, 0xc9, 0x32, 0xbe, 0x5e, 0x63, 0xec, 0x99, 0x3b, 0xc7, 0xf0, 0xbb, 0x5f,
	0xdf, 0x18, 0x34, 0xed, 0xd8, 0xaf, 0x2d, 0xb8, 0x32, 0x14, 0x7c, 0x37, 0xd3, 0xf2, 0xe4, 0x39,
	0xe8, 0xd7, 0x01, 0x8a, 0xca, 0xdd, 0xab, 0x38, 0xd4, 0x34, 0x33, 0x30, 0xb9, 0x0a, 0x97, 0x12,
	0x1c, 0x63, 0x62, 0xd1, 0xb6, 0x83, 0xe2, 0x87, 0xbe, 0x07, 0x8b, 0x3a, 0x4e, 0xb1, 0xb7, 0x64,
	0x29, 0x6c, 0xce, 0x56, 0xb4, 0x8f, 0xe3, 0x14, 0x03, 0x6b, 0x47, 0x57, 0x60, 0x21, 0x55, 0xbc,
	0x77, 0xd9, 0xfa, 0x34, 0x22, 0xbd, 0x01, 0xaf, 0x8c, 0x30, 0xc7, 0x6c, 0x84, 0x59, 0x74, 0x62,
	0xc1, 0x5c, 0xb1, 0x8b, 0x67, 0xb4, 0x94, 0x41, 0xd7, 0xf6, 0xe8, 0xb6, 0xc8, 0x34, 0x7e, 0xad,
	0x7b, 0x6d, 0xbb, 0xab, 0xa1, 0x63, 0xdf, 0x11, 0x58, 0x29, 0x0a, 0xfd, 0x69, 0xa8, 0xa3, 0xc3,
	0x5d, 0xb3, 0x66, 0x4a, 0xa2, 0x4f, 0xf2, 0xb2, 0x45, 0x8d, 0x6c, 0x0e, 0x8a, 0x38, 0x78, 0x88,
	0x91, 0x9e, 0xdf, 0x05, 0x56, 0xf8, 0xbb, 0xf3, 0xd7, 0x65, 0x58, 0x2e, 0x54, 0xfb, 0x28, 0xc7,
	0x71, 0x84, 0xf4, 0x47, 0x02, 0x9d, 0xda, 0x65, 0x4f, 0xfb, 0x9e, 0x9b, 0x6a, 0xe7, 0x27, 0x40,
	0x7f, 0xe7, 0xa2, 0x38, 0x8c, 0x4f, 0xf6, 0xfa, 0xf7, 0xff, 0xfc, 0xf7, 0xb8, 0xf5, 0x1a, 0xbd,
	0x66, 0xc7, 0xd9, 0x78, 0xe0, 0xc6, 0xa8, 0xf2, 0xbf, 0x29, 0x1b, 0xe4, 0x5b, 0x9a, 0x41, 0xa7,
	0x76, 0x26, 0x2a, 0x54, 0xe7, 0x0f, 0x4a, 0x7f, 0xa5, 0x44, 0xec, 0x9a, 0x8f, 0xf9, 0x36, 0xc2,
	0x9b, 0xf4, 0x66, 0x19, 0x41, 0x4b, 0x0c, 0xd3, 0x69, 0x81, 0xfc, 0x44, 0x70, 0xb5, 0x45, 0xa8,
	0x84, 0xae, 0x2d, 0xca, 0x2c, 0x69, 0xe8, 0x35, 0xc1, 0x54, 0xc5, 0x64, 0x9b, 0x36, 0xf0, 0x1b,
	0x94, 0x3d, 0x3f, 0xf0, 0x16, 0xa1, 0x3f, 0x11, 0xe8, 0xd6, 0xa7, 0x1b, 0xbd, 0x36, 0x71, 0x3c,
	0x65, 0xe6, 0xf5, 0x2f, 0xdc, 0x04, 0xec, 0x86, 0x45, 0xb7, 0xc1, 0x9e, 0x95, 0xf8, 0x77, 0xc9,
	0x26, 0xfd, 0x85, 0x40, 0xb7, 0x7e, 0xe3, 0x57, 0xb8, 0xa6, 0xcc, 0x81, 0x39, 0xe0, 0xba, 0x6d,
	0x71, 0xdd, 0xec, 0xb3, 0x67, 0xe0, 0x2a, 0x64, 0x0b, 0xef, 0x18, 0xba, 0xf5, 0x7b, 0xb4, 0x42,
	0x37, 0x65, 0x02, 0xf4, 0xd7, 0xa6, 0x2f, 0xba, 0xab, 0xd7, 0xd5, 0x6b, 0x73, 0x86, 0xc8, 0xf4,
	0x31, 0x81, 0x76, 0x39, 0xa0, 0x69, 0xd9, 0x03, 0x67, 0x67, 0xf6, 0x1c, 0xf2, 0x71, 0xbe, 0x8b,
	0x9e, 0x8a, 0xea, 0x83, 0xdd, 0x3f, 0x4f, 0xd7, 0xc9, 0xdf, 0xa7, 0xeb, 0xe4, 0xdf, 0xd3, 0x75,
	0xf2, 0xf9, 0xdb, 0x4f, 0x7d, 0x03, 0x3e, 0x12, 0xf2, 0xe8, 0xcb, 0x44, 0x3c, 0x2a, 0x9f, 0x81,
	0x8d, 0x97, 0xec, 0xc1, 0x92, 0x7d, 0xf9, 0xdd, 0x7d, 0x12, 0x00, 0x00, 0xff, 0xff, 0xb5, 0x3b,
	0x3b, 0x34, 0xe8, 0x0a, 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

// SensorServiceClient is the client API for SensorService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SensorServiceClient interface {
	ListSensors(ctx context.Context, in *ListSensorsRequest, opts ...grpc.CallOption) (*v1alpha1.SensorList, error)
	SensorsLogs(ctx context.Context, in *SensorsLogsRequest, opts ...grpc.CallOption) (SensorService_SensorsLogsClient, error)
	WatchSensors(ctx context.Context, in *ListSensorsRequest, opts ...grpc.CallOption) (SensorService_WatchSensorsClient, error)
	CreateSensor(ctx context.Context, in *CreateSensorRequest, opts ...grpc.CallOption) (*v1alpha1.Sensor, error)
	UpdateSensor(ctx context.Context, in *UpdateSensorRequest, opts ...grpc.CallOption) (*v1alpha1.Sensor, error)
	DeleteSensor(ctx context.Context, in *DeleteSensorRequest, opts ...grpc.CallOption) (*DeleteSensorResponse, error)
	GetSensor(ctx context.Context, in *GetSensorRequest, opts ...grpc.CallOption) (*v1alpha1.Sensor, error)
}

type sensorServiceClient struct {
	cc *grpc.ClientConn
}

func NewSensorServiceClient(cc *grpc.ClientConn) SensorServiceClient {
	return &sensorServiceClient{cc}
}

func (c *sensorServiceClient) ListSensors(ctx context.Context, in *ListSensorsRequest, opts ...grpc.CallOption) (*v1alpha1.SensorList, error) {
	out := new(v1alpha1.SensorList)
	err := c.cc.Invoke(ctx, "/sensor.SensorService/ListSensors", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sensorServiceClient) SensorsLogs(ctx context.Context, in *SensorsLogsRequest, opts ...grpc.CallOption) (SensorService_SensorsLogsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_SensorService_serviceDesc.Streams[0], "/sensor.SensorService/SensorsLogs", opts...)
	if err != nil {
		return nil, err
	}
	x := &sensorServiceSensorsLogsClient{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 SensorService_SensorsLogsClient interface {
	Recv() (*LogEntry, error)
	grpc.ClientStream
}

type sensorServiceSensorsLogsClient struct {
	grpc.ClientStream
}

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

func (c *sensorServiceClient) WatchSensors(ctx context.Context, in *ListSensorsRequest, opts ...grpc.CallOption) (SensorService_WatchSensorsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_SensorService_serviceDesc.Streams[1], "/sensor.SensorService/WatchSensors", opts...)
	if err != nil {
		return nil, err
	}
	x := &sensorServiceWatchSensorsClient{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 SensorService_WatchSensorsClient interface {
	Recv() (*SensorWatchEvent, error)
	grpc.ClientStream
}

type sensorServiceWatchSensorsClient struct {
	grpc.ClientStream
}

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

func (c *sensorServiceClient) CreateSensor(ctx context.Context, in *CreateSensorRequest, opts ...grpc.CallOption) (*v1alpha1.Sensor, error) {
	out := new(v1alpha1.Sensor)
	err := c.cc.Invoke(ctx, "/sensor.SensorService/CreateSensor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sensorServiceClient) UpdateSensor(ctx context.Context, in *UpdateSensorRequest, opts ...grpc.CallOption) (*v1alpha1.Sensor, error) {
	out := new(v1alpha1.Sensor)
	err := c.cc.Invoke(ctx, "/sensor.SensorService/UpdateSensor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sensorServiceClient) DeleteSensor(ctx context.Context, in *DeleteSensorRequest, opts ...grpc.CallOption) (*DeleteSensorResponse, error) {
	out := new(DeleteSensorResponse)
	err := c.cc.Invoke(ctx, "/sensor.SensorService/DeleteSensor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sensorServiceClient) GetSensor(ctx context.Context, in *GetSensorRequest, opts ...grpc.CallOption) (*v1alpha1.Sensor, error) {
	out := new(v1alpha1.Sensor)
	err := c.cc.Invoke(ctx, "/sensor.SensorService/GetSensor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SensorServiceServer is the server API for SensorService service.
type SensorServiceServer interface {
	ListSensors(context.Context, *ListSensorsRequest) (*v1alpha1.SensorList, error)
	SensorsLogs(*SensorsLogsRequest, SensorService_SensorsLogsServer) error
	WatchSensors(*ListSensorsRequest, SensorService_WatchSensorsServer) error
	CreateSensor(context.Context, *CreateSensorRequest) (*v1alpha1.Sensor, error)
	UpdateSensor(context.Context, *UpdateSensorRequest) (*v1alpha1.Sensor, error)
	DeleteSensor(context.Context, *DeleteSensorRequest) (*DeleteSensorResponse, error)
	GetSensor(context.Context, *GetSensorRequest) (*v1alpha1.Sensor, error)
}

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

func (*UnimplementedSensorServiceServer) ListSensors(ctx context.Context, req *ListSensorsRequest) (*v1alpha1.SensorList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSensors not implemented")
}
func (*UnimplementedSensorServiceServer) SensorsLogs(req *SensorsLogsRequest, srv SensorService_SensorsLogsServer) error {
	return status.Errorf(codes.Unimplemented, "method SensorsLogs not implemented")
}
func (*UnimplementedSensorServiceServer) WatchSensors(req *ListSensorsRequest, srv SensorService_WatchSensorsServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchSensors not implemented")
}
func (*UnimplementedSensorServiceServer) CreateSensor(ctx context.Context, req *CreateSensorRequest) (*v1alpha1.Sensor, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSensor not implemented")
}
func (*UnimplementedSensorServiceServer) UpdateSensor(ctx context.Context, req *UpdateSensorRequest) (*v1alpha1.Sensor, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSensor not implemented")
}
func (*UnimplementedSensorServiceServer) DeleteSensor(ctx context.Context, req *DeleteSensorRequest) (*DeleteSensorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSensor not implemented")
}
func (*UnimplementedSensorServiceServer) GetSensor(ctx context.Context, req *GetSensorRequest) (*v1alpha1.Sensor, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSensor not implemented")
}

func RegisterSensorServiceServer(s *grpc.Server, srv SensorServiceServer) {
	s.RegisterService(&_SensorService_serviceDesc, srv)
}

func _SensorService_ListSensors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSensorsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SensorServiceServer).ListSensors(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sensor.SensorService/ListSensors",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SensorServiceServer).ListSensors(ctx, req.(*ListSensorsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SensorService_SensorsLogs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SensorsLogsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SensorServiceServer).SensorsLogs(m, &sensorServiceSensorsLogsServer{stream})
}

type SensorService_SensorsLogsServer interface {
	Send(*LogEntry) error
	grpc.ServerStream
}

type sensorServiceSensorsLogsServer struct {
	grpc.ServerStream
}

func (x *sensorServiceSensorsLogsServer) Send(m *LogEntry) error {
	return x.ServerStream.SendMsg(m)
}

func _SensorService_WatchSensors_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListSensorsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SensorServiceServer).WatchSensors(m, &sensorServiceWatchSensorsServer{stream})
}

type SensorService_WatchSensorsServer interface {
	Send(*SensorWatchEvent) error
	grpc.ServerStream
}

type sensorServiceWatchSensorsServer struct {
	grpc.ServerStream
}

func (x *sensorServiceWatchSensorsServer) Send(m *SensorWatchEvent) error {
	return x.ServerStream.SendMsg(m)
}

func _SensorService_CreateSensor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSensorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SensorServiceServer).CreateSensor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sensor.SensorService/CreateSensor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SensorServiceServer).CreateSensor(ctx, req.(*CreateSensorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SensorService_UpdateSensor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSensorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SensorServiceServer).UpdateSensor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sensor.SensorService/UpdateSensor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SensorServiceServer).UpdateSensor(ctx, req.(*UpdateSensorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SensorService_DeleteSensor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteSensorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SensorServiceServer).DeleteSensor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sensor.SensorService/DeleteSensor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SensorServiceServer).DeleteSensor(ctx, req.(*DeleteSensorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SensorService_GetSensor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSensorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SensorServiceServer).GetSensor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sensor.SensorService/GetSensor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SensorServiceServer).GetSensor(ctx, req.(*GetSensorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _SensorService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "sensor.SensorService",
	HandlerType: (*SensorServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListSensors",
			Handler:    _SensorService_ListSensors_Handler,
		},
		{
			MethodName: "CreateSensor",
			Handler:    _SensorService_CreateSensor_Handler,
		},
		{
			MethodName: "UpdateSensor",
			Handler:    _SensorService_UpdateSensor_Handler,
		},
		{
			MethodName: "DeleteSensor",
			Handler:    _SensorService_DeleteSensor_Handler,
		},
		{
			MethodName: "GetSensor",
			Handler:    _SensorService_GetSensor_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SensorsLogs",
			Handler:       _SensorService_SensorsLogs_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WatchSensors",
			Handler:       _SensorService_WatchSensors_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pkg/apiclient/sensor/sensor.proto",
}

func (m *ListSensorsRequest) 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 *ListSensorsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListSensorsRequest) 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 m.ListOptions != nil {
		{
			size, err := m.ListOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CreateSensorRequest) 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 *CreateSensorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateSensorRequest) 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 m.CreateOptions != nil {
		{
			size, err := m.CreateOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Sensor != nil {
		{
			size, err := m.Sensor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetSensorRequest) 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 *GetSensorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetSensorRequest) 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 m.GetOptions != nil {
		{
			size, err := m.GetOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UpdateSensorRequest) 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 *UpdateSensorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateSensorRequest) 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 m.Sensor != nil {
		{
			size, err := m.Sensor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteSensorRequest) 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 *DeleteSensorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteSensorRequest) 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 m.DeleteOptions != nil {
		{
			size, err := m.DeleteOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteSensorResponse) 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 *DeleteSensorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteSensorResponse) 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 *SensorsLogsRequest) 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 *SensorsLogsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SensorsLogsRequest) 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 m.PodLogOptions != nil {
		{
			size, err := m.PodLogOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Grep) > 0 {
		i -= len(m.Grep)
		copy(dAtA[i:], m.Grep)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Grep)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.TriggerName) > 0 {
		i -= len(m.TriggerName)
		copy(dAtA[i:], m.TriggerName)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.TriggerName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LogEntry) 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 *LogEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogEntry) 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.EventContext) > 0 {
		i -= len(m.EventContext)
		copy(dAtA[i:], m.EventContext)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.EventContext)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.DependencyName) > 0 {
		i -= len(m.DependencyName)
		copy(dAtA[i:], m.DependencyName)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.DependencyName)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Msg) > 0 {
		i -= len(m.Msg)
		copy(dAtA[i:], m.Msg)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Msg)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Time != nil {
		{
			size, err := m.Time.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.Level) > 0 {
		i -= len(m.Level)
		copy(dAtA[i:], m.Level)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Level)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.TriggerName) > 0 {
		i -= len(m.TriggerName)
		copy(dAtA[i:], m.TriggerName)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.TriggerName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SensorName) > 0 {
		i -= len(m.SensorName)
		copy(dAtA[i:], m.SensorName)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.SensorName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SensorWatchEvent) 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 *SensorWatchEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SensorWatchEvent) 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 m.Object != nil {
		{
			size, err := m.Object.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSensor(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintSensor(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreateSensorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.Sensor != nil {
		l = m.Sensor.Size()
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.CreateOptions != nil {
		l = m.CreateOptions.Size()
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetSensorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.GetOptions != nil {
		l = m.GetOptions.Size()
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateSensorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.Sensor != nil {
		l = m.Sensor.Size()
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteSensorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.DeleteOptions != nil {
		l = m.DeleteOptions.Size()
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteSensorResponse) 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 *SensorsLogsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.TriggerName)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.Grep)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.PodLogOptions != nil {
		l = m.PodLogOptions.Size()
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LogEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.SensorName)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.TriggerName)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.Level)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.Time != nil {
		l = m.Time.Size()
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.DependencyName)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	l = len(m.EventContext)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SensorWatchEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.Object != nil {
		l = m.Object.Size()
		n += 1 + l + sovSensor(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovSensor(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSensor(x uint64) (n int) {
	return sovSensor(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ListSensorsRequest) 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 ErrIntOverflowSensor
			}
			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: ListSensorsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSensorsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ListOptions == nil {
				m.ListOptions = &v1.ListOptions{}
			}
			if err := m.ListOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 *CreateSensorRequest) 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 ErrIntOverflowSensor
			}
			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: CreateSensorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateSensorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sensor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sensor == nil {
				m.Sensor = &v1alpha1.Sensor{}
			}
			if err := m.Sensor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreateOptions == nil {
				m.CreateOptions = &v1.CreateOptions{}
			}
			if err := m.CreateOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 *GetSensorRequest) 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 ErrIntOverflowSensor
			}
			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: GetSensorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetSensorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetOptions == nil {
				m.GetOptions = &v1.GetOptions{}
			}
			if err := m.GetOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 *UpdateSensorRequest) 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 ErrIntOverflowSensor
			}
			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: UpdateSensorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateSensorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sensor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sensor == nil {
				m.Sensor = &v1alpha1.Sensor{}
			}
			if err := m.Sensor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 *DeleteSensorRequest) 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 ErrIntOverflowSensor
			}
			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: DeleteSensorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteSensorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeleteOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DeleteOptions == nil {
				m.DeleteOptions = &v1.DeleteOptions{}
			}
			if err := m.DeleteOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 *DeleteSensorResponse) 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 ErrIntOverflowSensor
			}
			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: DeleteSensorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteSensorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 *SensorsLogsRequest) 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 ErrIntOverflowSensor
			}
			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: SensorsLogsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SensorsLogsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TriggerName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Grep", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Grep = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodLogOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PodLogOptions == nil {
				m.PodLogOptions = &v11.PodLogOptions{}
			}
			if err := m.PodLogOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 *LogEntry) 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 ErrIntOverflowSensor
			}
			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: LogEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SensorName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SensorName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TriggerName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Level = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Time == nil {
				m.Time = &v1.Time{}
			}
			if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DependencyName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DependencyName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventContext", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventContext = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 *SensorWatchEvent) 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 ErrIntOverflowSensor
			}
			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: SensorWatchEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SensorWatchEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				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 ErrInvalidLengthSensor
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSensor
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSensor
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSensor
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Object == nil {
				m.Object = &v1alpha1.Sensor{}
			}
			if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSensor(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSensor
			}
			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 skipSensor(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, ErrIntOverflowSensor
			}
			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, ErrIntOverflowSensor
				}
				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, ErrIntOverflowSensor
				}
				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, ErrInvalidLengthSensor
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupSensor
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthSensor
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthSensor        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSensor          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSensor = fmt.Errorf("proto: unexpected end of group")
)
