// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v3.21.12
// source: ipc.proto

package ipc

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// MessageType indicates the type of message
type MessageType int32

const (
	MessageType_MESSAGE_TYPE_UNSPECIFIED       MessageType = 0
	MessageType_MESSAGE_TYPE_LOG               MessageType = 1
	MessageType_MESSAGE_TYPE_METRIC            MessageType = 2
	MessageType_MESSAGE_TYPE_EXEC_EVENT        MessageType = 3 // eBPF process execution event
	MessageType_MESSAGE_TYPE_CONNECT_EVENT     MessageType = 4 // eBPF network connection event
	MessageType_MESSAGE_TYPE_ACCEPT_EVENT      MessageType = 5 // eBPF accept (incoming connection) event
	MessageType_MESSAGE_TYPE_SOCKET_DATA_EVENT MessageType = 6 // eBPF sendto/recvfrom event
	MessageType_MESSAGE_TYPE_MMAP_EVENT        MessageType = 7 // eBPF mmap event
	MessageType_MESSAGE_TYPE_MPROTECT_EVENT    MessageType = 8 // eBPF mprotect event
	MessageType_MESSAGE_TYPE_FILE_EVENT        MessageType = 9 // eBPF file access event
)

// Enum value maps for MessageType.
var (
	MessageType_name = map[int32]string{
		0: "MESSAGE_TYPE_UNSPECIFIED",
		1: "MESSAGE_TYPE_LOG",
		2: "MESSAGE_TYPE_METRIC",
		3: "MESSAGE_TYPE_EXEC_EVENT",
		4: "MESSAGE_TYPE_CONNECT_EVENT",
		5: "MESSAGE_TYPE_ACCEPT_EVENT",
		6: "MESSAGE_TYPE_SOCKET_DATA_EVENT",
		7: "MESSAGE_TYPE_MMAP_EVENT",
		8: "MESSAGE_TYPE_MPROTECT_EVENT",
		9: "MESSAGE_TYPE_FILE_EVENT",
	}
	MessageType_value = map[string]int32{
		"MESSAGE_TYPE_UNSPECIFIED":       0,
		"MESSAGE_TYPE_LOG":               1,
		"MESSAGE_TYPE_METRIC":            2,
		"MESSAGE_TYPE_EXEC_EVENT":        3,
		"MESSAGE_TYPE_CONNECT_EVENT":     4,
		"MESSAGE_TYPE_ACCEPT_EVENT":      5,
		"MESSAGE_TYPE_SOCKET_DATA_EVENT": 6,
		"MESSAGE_TYPE_MMAP_EVENT":        7,
		"MESSAGE_TYPE_MPROTECT_EVENT":    8,
		"MESSAGE_TYPE_FILE_EVENT":        9,
	}
)

func (x MessageType) Enum() *MessageType {
	p := new(MessageType)
	*p = x
	return p
}

func (x MessageType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (MessageType) Descriptor() protoreflect.EnumDescriptor {
	return file_ipc_proto_enumTypes[0].Descriptor()
}

func (MessageType) Type() protoreflect.EnumType {
	return &file_ipc_proto_enumTypes[0]
}

func (x MessageType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use MessageType.Descriptor instead.
func (MessageType) EnumDescriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{0}
}

// StreamType indicates stdout or stderr
type StreamType int32

const (
	StreamType_STREAM_TYPE_UNSPECIFIED StreamType = 0
	StreamType_STREAM_TYPE_STDOUT      StreamType = 1
	StreamType_STREAM_TYPE_STDERR      StreamType = 2
)

// Enum value maps for StreamType.
var (
	StreamType_name = map[int32]string{
		0: "STREAM_TYPE_UNSPECIFIED",
		1: "STREAM_TYPE_STDOUT",
		2: "STREAM_TYPE_STDERR",
	}
	StreamType_value = map[string]int32{
		"STREAM_TYPE_UNSPECIFIED": 0,
		"STREAM_TYPE_STDOUT":      1,
		"STREAM_TYPE_STDERR":      2,
	}
)

func (x StreamType) Enum() *StreamType {
	p := new(StreamType)
	*p = x
	return p
}

func (x StreamType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (StreamType) Descriptor() protoreflect.EnumDescriptor {
	return file_ipc_proto_enumTypes[1].Descriptor()
}

func (StreamType) Type() protoreflect.EnumType {
	return &file_ipc_proto_enumTypes[1]
}

func (x StreamType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use StreamType.Descriptor instead.
func (StreamType) EnumDescriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{1}
}

// IPCMessage is the wire format for IPC communication
type IPCMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       uint32                 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`                       // Protocol version (currently 1)
	Type          MessageType            `protobuf:"varint,2,opt,name=type,proto3,enum=joblet.ipc.MessageType" json:"type,omitempty"` // Message type
	JobUuid       string                 `protobuf:"bytes,3,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`         // Job UUID
	Timestamp     int64                  `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`                   // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,5,opt,name=sequence,proto3" json:"sequence,omitempty"`                     // Message sequence number
	Data          []byte                 `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"`                              // Serialized payload (LogLine or Metric)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *IPCMessage) Reset() {
	*x = IPCMessage{}
	mi := &file_ipc_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *IPCMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*IPCMessage) ProtoMessage() {}

func (x *IPCMessage) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use IPCMessage.ProtoReflect.Descriptor instead.
func (*IPCMessage) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{0}
}

func (x *IPCMessage) GetVersion() uint32 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (x *IPCMessage) GetType() MessageType {
	if x != nil {
		return x.Type
	}
	return MessageType_MESSAGE_TYPE_UNSPECIFIED
}

func (x *IPCMessage) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *IPCMessage) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *IPCMessage) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *IPCMessage) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// LogLine represents a single log line from a job
type LogLine struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Stream        StreamType             `protobuf:"varint,2,opt,name=stream,proto3,enum=joblet.ipc.StreamType" json:"stream,omitempty"` // stdout or stderr
	Timestamp     int64                  `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`                      // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,4,opt,name=sequence,proto3" json:"sequence,omitempty"`                        // Sequence number
	Content       []byte                 `protobuf:"bytes,5,opt,name=content,proto3" json:"content,omitempty"`                           // Log line content
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LogLine) Reset() {
	*x = LogLine{}
	mi := &file_ipc_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *LogLine) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*LogLine) ProtoMessage() {}

func (x *LogLine) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use LogLine.ProtoReflect.Descriptor instead.
func (*LogLine) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{1}
}

func (x *LogLine) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *LogLine) GetStream() StreamType {
	if x != nil {
		return x.Stream
	}
	return StreamType_STREAM_TYPE_UNSPECIFIED
}

func (x *LogLine) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *LogLine) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *LogLine) GetContent() []byte {
	if x != nil {
		return x.Content
	}
	return nil
}

// Metric represents a metrics sample from a job
type Metric struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Timestamp     int64                  `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`   // Sequence number
	Data          *MetricData            `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`            // Metric values
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Metric) Reset() {
	*x = Metric{}
	mi := &file_ipc_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Metric) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Metric) ProtoMessage() {}

func (x *Metric) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Metric.ProtoReflect.Descriptor instead.
func (*Metric) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{2}
}

func (x *Metric) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *Metric) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *Metric) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *Metric) GetData() *MetricData {
	if x != nil {
		return x.Data
	}
	return nil
}

// MetricData contains the actual metric values
type MetricData struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	CpuUsage      float64                `protobuf:"fixed64,1,opt,name=cpu_usage,json=cpuUsage,proto3" json:"cpu_usage,omitempty"`         // CPU usage (0.0 - cores)
	MemoryUsage   int64                  `protobuf:"varint,2,opt,name=memory_usage,json=memoryUsage,proto3" json:"memory_usage,omitempty"` // Memory usage in bytes
	GpuUsage      float64                `protobuf:"fixed64,3,opt,name=gpu_usage,json=gpuUsage,proto3" json:"gpu_usage,omitempty"`         // GPU usage (0.0 - 1.0)
	DiskIo        *DiskIO                `protobuf:"bytes,4,opt,name=disk_io,json=diskIo,proto3" json:"disk_io,omitempty"`                 // Disk I/O statistics
	NetworkIo     *NetworkIO             `protobuf:"bytes,5,opt,name=network_io,json=networkIo,proto3" json:"network_io,omitempty"`        // Network I/O statistics
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MetricData) Reset() {
	*x = MetricData{}
	mi := &file_ipc_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MetricData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MetricData) ProtoMessage() {}

func (x *MetricData) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MetricData.ProtoReflect.Descriptor instead.
func (*MetricData) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{3}
}

func (x *MetricData) GetCpuUsage() float64 {
	if x != nil {
		return x.CpuUsage
	}
	return 0
}

func (x *MetricData) GetMemoryUsage() int64 {
	if x != nil {
		return x.MemoryUsage
	}
	return 0
}

func (x *MetricData) GetGpuUsage() float64 {
	if x != nil {
		return x.GpuUsage
	}
	return 0
}

func (x *MetricData) GetDiskIo() *DiskIO {
	if x != nil {
		return x.DiskIo
	}
	return nil
}

func (x *MetricData) GetNetworkIo() *NetworkIO {
	if x != nil {
		return x.NetworkIo
	}
	return nil
}

// DiskIO represents disk I/O statistics
type DiskIO struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ReadBytes     int64                  `protobuf:"varint,1,opt,name=read_bytes,json=readBytes,proto3" json:"read_bytes,omitempty"`
	WriteBytes    int64                  `protobuf:"varint,2,opt,name=write_bytes,json=writeBytes,proto3" json:"write_bytes,omitempty"`
	ReadOps       int64                  `protobuf:"varint,3,opt,name=read_ops,json=readOps,proto3" json:"read_ops,omitempty"`
	WriteOps      int64                  `protobuf:"varint,4,opt,name=write_ops,json=writeOps,proto3" json:"write_ops,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DiskIO) Reset() {
	*x = DiskIO{}
	mi := &file_ipc_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DiskIO) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DiskIO) ProtoMessage() {}

func (x *DiskIO) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DiskIO.ProtoReflect.Descriptor instead.
func (*DiskIO) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{4}
}

func (x *DiskIO) GetReadBytes() int64 {
	if x != nil {
		return x.ReadBytes
	}
	return 0
}

func (x *DiskIO) GetWriteBytes() int64 {
	if x != nil {
		return x.WriteBytes
	}
	return 0
}

func (x *DiskIO) GetReadOps() int64 {
	if x != nil {
		return x.ReadOps
	}
	return 0
}

func (x *DiskIO) GetWriteOps() int64 {
	if x != nil {
		return x.WriteOps
	}
	return 0
}

// NetworkIO represents network I/O statistics
type NetworkIO struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RxBytes       int64                  `protobuf:"varint,1,opt,name=rx_bytes,json=rxBytes,proto3" json:"rx_bytes,omitempty"`
	TxBytes       int64                  `protobuf:"varint,2,opt,name=tx_bytes,json=txBytes,proto3" json:"tx_bytes,omitempty"`
	RxPackets     int64                  `protobuf:"varint,3,opt,name=rx_packets,json=rxPackets,proto3" json:"rx_packets,omitempty"`
	TxPackets     int64                  `protobuf:"varint,4,opt,name=tx_packets,json=txPackets,proto3" json:"tx_packets,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NetworkIO) Reset() {
	*x = NetworkIO{}
	mi := &file_ipc_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NetworkIO) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NetworkIO) ProtoMessage() {}

func (x *NetworkIO) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NetworkIO.ProtoReflect.Descriptor instead.
func (*NetworkIO) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{5}
}

func (x *NetworkIO) GetRxBytes() int64 {
	if x != nil {
		return x.RxBytes
	}
	return 0
}

func (x *NetworkIO) GetTxBytes() int64 {
	if x != nil {
		return x.TxBytes
	}
	return 0
}

func (x *NetworkIO) GetRxPackets() int64 {
	if x != nil {
		return x.RxPackets
	}
	return 0
}

func (x *NetworkIO) GetTxPackets() int64 {
	if x != nil {
		return x.TxPackets
	}
	return 0
}

// ExecEvent represents a process execution event from eBPF telematics
type ExecEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Timestamp     int64                  `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`   // Sequence number
	Pid           uint32                 `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`             // Process ID
	Ppid          uint32                 `protobuf:"varint,5,opt,name=ppid,proto3" json:"ppid,omitempty"`           // Parent process ID
	Uid           uint32                 `protobuf:"varint,6,opt,name=uid,proto3" json:"uid,omitempty"`             // User ID
	Gid           uint32                 `protobuf:"varint,7,opt,name=gid,proto3" json:"gid,omitempty"`             // Group ID
	Comm          string                 `protobuf:"bytes,8,opt,name=comm,proto3" json:"comm,omitempty"`            // Process command name (max 16 chars)
	Filename      string                 `protobuf:"bytes,9,opt,name=filename,proto3" json:"filename,omitempty"`    // Full path to executable
	Args          []string               `protobuf:"bytes,10,rep,name=args,proto3" json:"args,omitempty"`           // Command arguments
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ExecEvent) Reset() {
	*x = ExecEvent{}
	mi := &file_ipc_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ExecEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ExecEvent) ProtoMessage() {}

func (x *ExecEvent) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ExecEvent.ProtoReflect.Descriptor instead.
func (*ExecEvent) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{6}
}

func (x *ExecEvent) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *ExecEvent) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *ExecEvent) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *ExecEvent) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *ExecEvent) GetPpid() uint32 {
	if x != nil {
		return x.Ppid
	}
	return 0
}

func (x *ExecEvent) GetUid() uint32 {
	if x != nil {
		return x.Uid
	}
	return 0
}

func (x *ExecEvent) GetGid() uint32 {
	if x != nil {
		return x.Gid
	}
	return 0
}

func (x *ExecEvent) GetComm() string {
	if x != nil {
		return x.Comm
	}
	return ""
}

func (x *ExecEvent) GetFilename() string {
	if x != nil {
		return x.Filename
	}
	return ""
}

func (x *ExecEvent) GetArgs() []string {
	if x != nil {
		return x.Args
	}
	return nil
}

// ConnectEvent represents a network connection event from eBPF telematics
type ConnectEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Timestamp     int64                  `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`            // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`              // Sequence number
	Pid           uint32                 `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`                        // Process ID
	Comm          string                 `protobuf:"bytes,5,opt,name=comm,proto3" json:"comm,omitempty"`                       // Process command name
	SrcAddr       string                 `protobuf:"bytes,6,opt,name=src_addr,json=srcAddr,proto3" json:"src_addr,omitempty"`  // Source IP address
	SrcPort       uint32                 `protobuf:"varint,7,opt,name=src_port,json=srcPort,proto3" json:"src_port,omitempty"` // Source port
	DstAddr       string                 `protobuf:"bytes,8,opt,name=dst_addr,json=dstAddr,proto3" json:"dst_addr,omitempty"`  // Destination IP address
	DstPort       uint32                 `protobuf:"varint,9,opt,name=dst_port,json=dstPort,proto3" json:"dst_port,omitempty"` // Destination port
	Protocol      string                 `protobuf:"bytes,10,opt,name=protocol,proto3" json:"protocol,omitempty"`              // Protocol (TCP, UDP)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConnectEvent) Reset() {
	*x = ConnectEvent{}
	mi := &file_ipc_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConnectEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConnectEvent) ProtoMessage() {}

func (x *ConnectEvent) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ConnectEvent.ProtoReflect.Descriptor instead.
func (*ConnectEvent) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{7}
}

func (x *ConnectEvent) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *ConnectEvent) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *ConnectEvent) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *ConnectEvent) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *ConnectEvent) GetComm() string {
	if x != nil {
		return x.Comm
	}
	return ""
}

func (x *ConnectEvent) GetSrcAddr() string {
	if x != nil {
		return x.SrcAddr
	}
	return ""
}

func (x *ConnectEvent) GetSrcPort() uint32 {
	if x != nil {
		return x.SrcPort
	}
	return 0
}

func (x *ConnectEvent) GetDstAddr() string {
	if x != nil {
		return x.DstAddr
	}
	return ""
}

func (x *ConnectEvent) GetDstPort() uint32 {
	if x != nil {
		return x.DstPort
	}
	return 0
}

func (x *ConnectEvent) GetProtocol() string {
	if x != nil {
		return x.Protocol
	}
	return ""
}

// AcceptEvent represents an incoming connection accept from eBPF telematics
type AcceptEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Timestamp     int64                  `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`            // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`              // Sequence number
	Pid           uint32                 `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`                        // Process ID
	Comm          string                 `protobuf:"bytes,5,opt,name=comm,proto3" json:"comm,omitempty"`                       // Process command name
	SrcAddr       string                 `protobuf:"bytes,6,opt,name=src_addr,json=srcAddr,proto3" json:"src_addr,omitempty"`  // Remote (client) IP address
	SrcPort       uint32                 `protobuf:"varint,7,opt,name=src_port,json=srcPort,proto3" json:"src_port,omitempty"` // Remote (client) port
	DstAddr       string                 `protobuf:"bytes,8,opt,name=dst_addr,json=dstAddr,proto3" json:"dst_addr,omitempty"`  // Local IP address
	DstPort       uint32                 `protobuf:"varint,9,opt,name=dst_port,json=dstPort,proto3" json:"dst_port,omitempty"` // Local port (listening port)
	Protocol      string                 `protobuf:"bytes,10,opt,name=protocol,proto3" json:"protocol,omitempty"`              // Protocol (TCP)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AcceptEvent) Reset() {
	*x = AcceptEvent{}
	mi := &file_ipc_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AcceptEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AcceptEvent) ProtoMessage() {}

func (x *AcceptEvent) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AcceptEvent.ProtoReflect.Descriptor instead.
func (*AcceptEvent) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{8}
}

func (x *AcceptEvent) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *AcceptEvent) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *AcceptEvent) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *AcceptEvent) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *AcceptEvent) GetComm() string {
	if x != nil {
		return x.Comm
	}
	return ""
}

func (x *AcceptEvent) GetSrcAddr() string {
	if x != nil {
		return x.SrcAddr
	}
	return ""
}

func (x *AcceptEvent) GetSrcPort() uint32 {
	if x != nil {
		return x.SrcPort
	}
	return 0
}

func (x *AcceptEvent) GetDstAddr() string {
	if x != nil {
		return x.DstAddr
	}
	return ""
}

func (x *AcceptEvent) GetDstPort() uint32 {
	if x != nil {
		return x.DstPort
	}
	return 0
}

func (x *AcceptEvent) GetProtocol() string {
	if x != nil {
		return x.Protocol
	}
	return ""
}

// SocketDataEvent represents sendto/recvfrom events from eBPF telematics
type SocketDataEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Timestamp     int64                  `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`   // Sequence number
	Pid           uint32                 `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`             // Process ID
	Comm          string                 `protobuf:"bytes,5,opt,name=comm,proto3" json:"comm,omitempty"`            // Process command name
	Direction     string                 `protobuf:"bytes,6,opt,name=direction,proto3" json:"direction,omitempty"`  // "send" or "recv"
	Addr          string                 `protobuf:"bytes,7,opt,name=addr,proto3" json:"addr,omitempty"`            // Remote IP address
	Port          uint32                 `protobuf:"varint,8,opt,name=port,proto3" json:"port,omitempty"`           // Remote port
	Protocol      string                 `protobuf:"bytes,9,opt,name=protocol,proto3" json:"protocol,omitempty"`    // Protocol (TCP, UDP)
	Bytes         int64                  `protobuf:"varint,10,opt,name=bytes,proto3" json:"bytes,omitempty"`        // Bytes transferred
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SocketDataEvent) Reset() {
	*x = SocketDataEvent{}
	mi := &file_ipc_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SocketDataEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SocketDataEvent) ProtoMessage() {}

func (x *SocketDataEvent) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SocketDataEvent.ProtoReflect.Descriptor instead.
func (*SocketDataEvent) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{9}
}

func (x *SocketDataEvent) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *SocketDataEvent) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *SocketDataEvent) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *SocketDataEvent) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *SocketDataEvent) GetComm() string {
	if x != nil {
		return x.Comm
	}
	return ""
}

func (x *SocketDataEvent) GetDirection() string {
	if x != nil {
		return x.Direction
	}
	return ""
}

func (x *SocketDataEvent) GetAddr() string {
	if x != nil {
		return x.Addr
	}
	return ""
}

func (x *SocketDataEvent) GetPort() uint32 {
	if x != nil {
		return x.Port
	}
	return 0
}

func (x *SocketDataEvent) GetProtocol() string {
	if x != nil {
		return x.Protocol
	}
	return ""
}

func (x *SocketDataEvent) GetBytes() int64 {
	if x != nil {
		return x.Bytes
	}
	return 0
}

// MmapEvent represents memory mapping events from eBPF telematics
type MmapEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Timestamp     int64                  `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`   // Sequence number
	Pid           uint32                 `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`             // Process ID
	Comm          string                 `protobuf:"bytes,5,opt,name=comm,proto3" json:"comm,omitempty"`            // Process command name
	Addr          uint64                 `protobuf:"varint,6,opt,name=addr,proto3" json:"addr,omitempty"`           // Memory address
	Length        uint64                 `protobuf:"varint,7,opt,name=length,proto3" json:"length,omitempty"`       // Mapping length
	Prot          uint32                 `protobuf:"varint,8,opt,name=prot,proto3" json:"prot,omitempty"`           // Protection flags (PROT_READ, PROT_WRITE, PROT_EXEC)
	Flags         uint32                 `protobuf:"varint,9,opt,name=flags,proto3" json:"flags,omitempty"`         // Mapping flags (MAP_SHARED, MAP_PRIVATE, MAP_ANONYMOUS)
	Filename      string                 `protobuf:"bytes,10,opt,name=filename,proto3" json:"filename,omitempty"`   // File being mapped (if file-backed)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MmapEvent) Reset() {
	*x = MmapEvent{}
	mi := &file_ipc_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MmapEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MmapEvent) ProtoMessage() {}

func (x *MmapEvent) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MmapEvent.ProtoReflect.Descriptor instead.
func (*MmapEvent) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{10}
}

func (x *MmapEvent) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *MmapEvent) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *MmapEvent) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *MmapEvent) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *MmapEvent) GetComm() string {
	if x != nil {
		return x.Comm
	}
	return ""
}

func (x *MmapEvent) GetAddr() uint64 {
	if x != nil {
		return x.Addr
	}
	return 0
}

func (x *MmapEvent) GetLength() uint64 {
	if x != nil {
		return x.Length
	}
	return 0
}

func (x *MmapEvent) GetProt() uint32 {
	if x != nil {
		return x.Prot
	}
	return 0
}

func (x *MmapEvent) GetFlags() uint32 {
	if x != nil {
		return x.Flags
	}
	return 0
}

func (x *MmapEvent) GetFilename() string {
	if x != nil {
		return x.Filename
	}
	return ""
}

// MprotectEvent represents memory protection change events from eBPF telematics
type MprotectEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Timestamp     int64                  `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`   // Sequence number
	Pid           uint32                 `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`             // Process ID
	Comm          string                 `protobuf:"bytes,5,opt,name=comm,proto3" json:"comm,omitempty"`            // Process command name
	Addr          uint64                 `protobuf:"varint,6,opt,name=addr,proto3" json:"addr,omitempty"`           // Memory address
	Length        uint64                 `protobuf:"varint,7,opt,name=length,proto3" json:"length,omitempty"`       // Region length
	Prot          uint32                 `protobuf:"varint,8,opt,name=prot,proto3" json:"prot,omitempty"`           // New protection flags (PROT_READ, PROT_WRITE, PROT_EXEC)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MprotectEvent) Reset() {
	*x = MprotectEvent{}
	mi := &file_ipc_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MprotectEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MprotectEvent) ProtoMessage() {}

func (x *MprotectEvent) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MprotectEvent.ProtoReflect.Descriptor instead.
func (*MprotectEvent) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{11}
}

func (x *MprotectEvent) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *MprotectEvent) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *MprotectEvent) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *MprotectEvent) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *MprotectEvent) GetComm() string {
	if x != nil {
		return x.Comm
	}
	return ""
}

func (x *MprotectEvent) GetAddr() uint64 {
	if x != nil {
		return x.Addr
	}
	return 0
}

func (x *MprotectEvent) GetLength() uint64 {
	if x != nil {
		return x.Length
	}
	return 0
}

func (x *MprotectEvent) GetProt() uint32 {
	if x != nil {
		return x.Prot
	}
	return 0
}

// FileEvent represents file access events from eBPF telematics
type FileEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	JobUuid       string                 `protobuf:"bytes,1,opt,name=job_uuid,json=jobUuid,proto3" json:"job_uuid,omitempty"`
	Timestamp     int64                  `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Unix nanoseconds
	Sequence      uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`   // Sequence number
	Pid           uint32                 `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`             // Process ID
	Comm          string                 `protobuf:"bytes,5,opt,name=comm,proto3" json:"comm,omitempty"`            // Process command name
	Path          string                 `protobuf:"bytes,6,opt,name=path,proto3" json:"path,omitempty"`            // File path
	Operation     string                 `protobuf:"bytes,7,opt,name=operation,proto3" json:"operation,omitempty"`  // "read", "write", "create", "delete"
	Bytes         int64                  `protobuf:"varint,8,opt,name=bytes,proto3" json:"bytes,omitempty"`         // Bytes read/written (if applicable)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FileEvent) Reset() {
	*x = FileEvent{}
	mi := &file_ipc_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FileEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FileEvent) ProtoMessage() {}

func (x *FileEvent) ProtoReflect() protoreflect.Message {
	mi := &file_ipc_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FileEvent.ProtoReflect.Descriptor instead.
func (*FileEvent) Descriptor() ([]byte, []int) {
	return file_ipc_proto_rawDescGZIP(), []int{12}
}

func (x *FileEvent) GetJobUuid() string {
	if x != nil {
		return x.JobUuid
	}
	return ""
}

func (x *FileEvent) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *FileEvent) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *FileEvent) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *FileEvent) GetComm() string {
	if x != nil {
		return x.Comm
	}
	return ""
}

func (x *FileEvent) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *FileEvent) GetOperation() string {
	if x != nil {
		return x.Operation
	}
	return ""
}

func (x *FileEvent) GetBytes() int64 {
	if x != nil {
		return x.Bytes
	}
	return 0
}

var File_ipc_proto protoreflect.FileDescriptor

const file_ipc_proto_rawDesc = "" +
	"\n" +
	"\tipc.proto\x12\n" +
	"joblet.ipc\"\xbc\x01\n" +
	"\n" +
	"IPCMessage\x12\x18\n" +
	"\aversion\x18\x01 \x01(\rR\aversion\x12+\n" +
	"\x04type\x18\x02 \x01(\x0e2\x17.joblet.ipc.MessageTypeR\x04type\x12\x19\n" +
	"\bjob_uuid\x18\x03 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x04 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x05 \x01(\x04R\bsequence\x12\x12\n" +
	"\x04data\x18\x06 \x01(\fR\x04data\"\xa8\x01\n" +
	"\aLogLine\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12.\n" +
	"\x06stream\x18\x02 \x01(\x0e2\x16.joblet.ipc.StreamTypeR\x06stream\x12\x1c\n" +
	"\ttimestamp\x18\x03 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x04 \x01(\x04R\bsequence\x12\x18\n" +
	"\acontent\x18\x05 \x01(\fR\acontent\"\x89\x01\n" +
	"\x06Metric\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12*\n" +
	"\x04data\x18\x04 \x01(\v2\x16.joblet.ipc.MetricDataR\x04data\"\xcc\x01\n" +
	"\n" +
	"MetricData\x12\x1b\n" +
	"\tcpu_usage\x18\x01 \x01(\x01R\bcpuUsage\x12!\n" +
	"\fmemory_usage\x18\x02 \x01(\x03R\vmemoryUsage\x12\x1b\n" +
	"\tgpu_usage\x18\x03 \x01(\x01R\bgpuUsage\x12+\n" +
	"\adisk_io\x18\x04 \x01(\v2\x12.joblet.ipc.DiskIOR\x06diskIo\x124\n" +
	"\n" +
	"network_io\x18\x05 \x01(\v2\x15.joblet.ipc.NetworkIOR\tnetworkIo\"\x80\x01\n" +
	"\x06DiskIO\x12\x1d\n" +
	"\n" +
	"read_bytes\x18\x01 \x01(\x03R\treadBytes\x12\x1f\n" +
	"\vwrite_bytes\x18\x02 \x01(\x03R\n" +
	"writeBytes\x12\x19\n" +
	"\bread_ops\x18\x03 \x01(\x03R\areadOps\x12\x1b\n" +
	"\twrite_ops\x18\x04 \x01(\x03R\bwriteOps\"\x7f\n" +
	"\tNetworkIO\x12\x19\n" +
	"\brx_bytes\x18\x01 \x01(\x03R\arxBytes\x12\x19\n" +
	"\btx_bytes\x18\x02 \x01(\x03R\atxBytes\x12\x1d\n" +
	"\n" +
	"rx_packets\x18\x03 \x01(\x03R\trxPackets\x12\x1d\n" +
	"\n" +
	"tx_packets\x18\x04 \x01(\x03R\ttxPackets\"\xee\x01\n" +
	"\tExecEvent\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12\x10\n" +
	"\x03pid\x18\x04 \x01(\rR\x03pid\x12\x12\n" +
	"\x04ppid\x18\x05 \x01(\rR\x04ppid\x12\x10\n" +
	"\x03uid\x18\x06 \x01(\rR\x03uid\x12\x10\n" +
	"\x03gid\x18\a \x01(\rR\x03gid\x12\x12\n" +
	"\x04comm\x18\b \x01(\tR\x04comm\x12\x1a\n" +
	"\bfilename\x18\t \x01(\tR\bfilename\x12\x12\n" +
	"\x04args\x18\n" +
	" \x03(\tR\x04args\"\x91\x02\n" +
	"\fConnectEvent\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12\x10\n" +
	"\x03pid\x18\x04 \x01(\rR\x03pid\x12\x12\n" +
	"\x04comm\x18\x05 \x01(\tR\x04comm\x12\x19\n" +
	"\bsrc_addr\x18\x06 \x01(\tR\asrcAddr\x12\x19\n" +
	"\bsrc_port\x18\a \x01(\rR\asrcPort\x12\x19\n" +
	"\bdst_addr\x18\b \x01(\tR\adstAddr\x12\x19\n" +
	"\bdst_port\x18\t \x01(\rR\adstPort\x12\x1a\n" +
	"\bprotocol\x18\n" +
	" \x01(\tR\bprotocol\"\x90\x02\n" +
	"\vAcceptEvent\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12\x10\n" +
	"\x03pid\x18\x04 \x01(\rR\x03pid\x12\x12\n" +
	"\x04comm\x18\x05 \x01(\tR\x04comm\x12\x19\n" +
	"\bsrc_addr\x18\x06 \x01(\tR\asrcAddr\x12\x19\n" +
	"\bsrc_port\x18\a \x01(\rR\asrcPort\x12\x19\n" +
	"\bdst_addr\x18\b \x01(\tR\adstAddr\x12\x19\n" +
	"\bdst_port\x18\t \x01(\rR\adstPort\x12\x1a\n" +
	"\bprotocol\x18\n" +
	" \x01(\tR\bprotocol\"\x84\x02\n" +
	"\x0fSocketDataEvent\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12\x10\n" +
	"\x03pid\x18\x04 \x01(\rR\x03pid\x12\x12\n" +
	"\x04comm\x18\x05 \x01(\tR\x04comm\x12\x1c\n" +
	"\tdirection\x18\x06 \x01(\tR\tdirection\x12\x12\n" +
	"\x04addr\x18\a \x01(\tR\x04addr\x12\x12\n" +
	"\x04port\x18\b \x01(\rR\x04port\x12\x1a\n" +
	"\bprotocol\x18\t \x01(\tR\bprotocol\x12\x14\n" +
	"\x05bytes\x18\n" +
	" \x01(\x03R\x05bytes\"\xf8\x01\n" +
	"\tMmapEvent\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12\x10\n" +
	"\x03pid\x18\x04 \x01(\rR\x03pid\x12\x12\n" +
	"\x04comm\x18\x05 \x01(\tR\x04comm\x12\x12\n" +
	"\x04addr\x18\x06 \x01(\x04R\x04addr\x12\x16\n" +
	"\x06length\x18\a \x01(\x04R\x06length\x12\x12\n" +
	"\x04prot\x18\b \x01(\rR\x04prot\x12\x14\n" +
	"\x05flags\x18\t \x01(\rR\x05flags\x12\x1a\n" +
	"\bfilename\x18\n" +
	" \x01(\tR\bfilename\"\xca\x01\n" +
	"\rMprotectEvent\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12\x10\n" +
	"\x03pid\x18\x04 \x01(\rR\x03pid\x12\x12\n" +
	"\x04comm\x18\x05 \x01(\tR\x04comm\x12\x12\n" +
	"\x04addr\x18\x06 \x01(\x04R\x04addr\x12\x16\n" +
	"\x06length\x18\a \x01(\x04R\x06length\x12\x12\n" +
	"\x04prot\x18\b \x01(\rR\x04prot\"\xce\x01\n" +
	"\tFileEvent\x12\x19\n" +
	"\bjob_uuid\x18\x01 \x01(\tR\ajobUuid\x12\x1c\n" +
	"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12\x10\n" +
	"\x03pid\x18\x04 \x01(\rR\x03pid\x12\x12\n" +
	"\x04comm\x18\x05 \x01(\tR\x04comm\x12\x12\n" +
	"\x04path\x18\x06 \x01(\tR\x04path\x12\x1c\n" +
	"\toperation\x18\a \x01(\tR\toperation\x12\x14\n" +
	"\x05bytes\x18\b \x01(\x03R\x05bytes*\xb5\x02\n" +
	"\vMessageType\x12\x1c\n" +
	"\x18MESSAGE_TYPE_UNSPECIFIED\x10\x00\x12\x14\n" +
	"\x10MESSAGE_TYPE_LOG\x10\x01\x12\x17\n" +
	"\x13MESSAGE_TYPE_METRIC\x10\x02\x12\x1b\n" +
	"\x17MESSAGE_TYPE_EXEC_EVENT\x10\x03\x12\x1e\n" +
	"\x1aMESSAGE_TYPE_CONNECT_EVENT\x10\x04\x12\x1d\n" +
	"\x19MESSAGE_TYPE_ACCEPT_EVENT\x10\x05\x12\"\n" +
	"\x1eMESSAGE_TYPE_SOCKET_DATA_EVENT\x10\x06\x12\x1b\n" +
	"\x17MESSAGE_TYPE_MMAP_EVENT\x10\a\x12\x1f\n" +
	"\x1bMESSAGE_TYPE_MPROTECT_EVENT\x10\b\x12\x1b\n" +
	"\x17MESSAGE_TYPE_FILE_EVENT\x10\t*Y\n" +
	"\n" +
	"StreamType\x12\x1b\n" +
	"\x17STREAM_TYPE_UNSPECIFIED\x10\x00\x12\x16\n" +
	"\x12STREAM_TYPE_STDOUT\x10\x01\x12\x16\n" +
	"\x12STREAM_TYPE_STDERR\x10\x02B4Z2github.com/ehsaniara/joblet/internal/proto/gen/ipcb\x06proto3"

var (
	file_ipc_proto_rawDescOnce sync.Once
	file_ipc_proto_rawDescData []byte
)

func file_ipc_proto_rawDescGZIP() []byte {
	file_ipc_proto_rawDescOnce.Do(func() {
		file_ipc_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ipc_proto_rawDesc), len(file_ipc_proto_rawDesc)))
	})
	return file_ipc_proto_rawDescData
}

var file_ipc_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_ipc_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
var file_ipc_proto_goTypes = []any{
	(MessageType)(0),        // 0: joblet.ipc.MessageType
	(StreamType)(0),         // 1: joblet.ipc.StreamType
	(*IPCMessage)(nil),      // 2: joblet.ipc.IPCMessage
	(*LogLine)(nil),         // 3: joblet.ipc.LogLine
	(*Metric)(nil),          // 4: joblet.ipc.Metric
	(*MetricData)(nil),      // 5: joblet.ipc.MetricData
	(*DiskIO)(nil),          // 6: joblet.ipc.DiskIO
	(*NetworkIO)(nil),       // 7: joblet.ipc.NetworkIO
	(*ExecEvent)(nil),       // 8: joblet.ipc.ExecEvent
	(*ConnectEvent)(nil),    // 9: joblet.ipc.ConnectEvent
	(*AcceptEvent)(nil),     // 10: joblet.ipc.AcceptEvent
	(*SocketDataEvent)(nil), // 11: joblet.ipc.SocketDataEvent
	(*MmapEvent)(nil),       // 12: joblet.ipc.MmapEvent
	(*MprotectEvent)(nil),   // 13: joblet.ipc.MprotectEvent
	(*FileEvent)(nil),       // 14: joblet.ipc.FileEvent
}
var file_ipc_proto_depIdxs = []int32{
	0, // 0: joblet.ipc.IPCMessage.type:type_name -> joblet.ipc.MessageType
	1, // 1: joblet.ipc.LogLine.stream:type_name -> joblet.ipc.StreamType
	5, // 2: joblet.ipc.Metric.data:type_name -> joblet.ipc.MetricData
	6, // 3: joblet.ipc.MetricData.disk_io:type_name -> joblet.ipc.DiskIO
	7, // 4: joblet.ipc.MetricData.network_io:type_name -> joblet.ipc.NetworkIO
	5, // [5:5] is the sub-list for method output_type
	5, // [5:5] is the sub-list for method input_type
	5, // [5:5] is the sub-list for extension type_name
	5, // [5:5] is the sub-list for extension extendee
	0, // [0:5] is the sub-list for field type_name
}

func init() { file_ipc_proto_init() }
func file_ipc_proto_init() {
	if File_ipc_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_ipc_proto_rawDesc), len(file_ipc_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   13,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_ipc_proto_goTypes,
		DependencyIndexes: file_ipc_proto_depIdxs,
		EnumInfos:         file_ipc_proto_enumTypes,
		MessageInfos:      file_ipc_proto_msgTypes,
	}.Build()
	File_ipc_proto = out.File
	file_ipc_proto_goTypes = nil
	file_ipc_proto_depIdxs = nil
}
