// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.34.1
// source: uart_messages.proto

package pb

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

type MessageType int32

const (
	MessageType_UNKNOWN             MessageType = 0
	MessageType_ACK                 MessageType = 1
	MessageType_ECHO                MessageType = 2
	MessageType_VERSION             MessageType = 3
	MessageType_CLIENT_INFO         MessageType = 4
	MessageType_CLIENT_INPUT        MessageType = 5
	MessageType_ACCEL_DEADZONE      MessageType = 6
	MessageType_ESPNOW_UNICAST_TEST MessageType = 7
	MessageType_LED_RING            MessageType = 8
	MessageType_OTA_START           MessageType = 16
	MessageType_OTA_PAYLOAD         MessageType = 17
	MessageType_OTA_END             MessageType = 18
	MessageType_OTA_STATUS          MessageType = 19
	MessageType_OTA_START_ESPNOW    MessageType = 20
	MessageType_OTA_SLAVE_PROGRESS  MessageType = 21
)

// Enum value maps for MessageType.
var (
	MessageType_name = map[int32]string{
		0:  "UNKNOWN",
		1:  "ACK",
		2:  "ECHO",
		3:  "VERSION",
		4:  "CLIENT_INFO",
		5:  "CLIENT_INPUT",
		6:  "ACCEL_DEADZONE",
		7:  "ESPNOW_UNICAST_TEST",
		8:  "LED_RING",
		16: "OTA_START",
		17: "OTA_PAYLOAD",
		18: "OTA_END",
		19: "OTA_STATUS",
		20: "OTA_START_ESPNOW",
		21: "OTA_SLAVE_PROGRESS",
	}
	MessageType_value = map[string]int32{
		"UNKNOWN":             0,
		"ACK":                 1,
		"ECHO":                2,
		"VERSION":             3,
		"CLIENT_INFO":         4,
		"CLIENT_INPUT":        5,
		"ACCEL_DEADZONE":      6,
		"ESPNOW_UNICAST_TEST": 7,
		"LED_RING":            8,
		"OTA_START":           16,
		"OTA_PAYLOAD":         17,
		"OTA_END":             18,
		"OTA_STATUS":          19,
		"OTA_START_ESPNOW":    20,
		"OTA_SLAVE_PROGRESS":  21,
	}
)

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_uart_messages_proto_enumTypes[0].Descriptor()
}

func (MessageType) Type() protoreflect.EnumType {
	return &file_uart_messages_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_uart_messages_proto_rawDescGZIP(), []int{0}
}

type UartMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Type  MessageType            `protobuf:"varint,1,opt,name=type,proto3,enum=alox.MessageType" json:"type,omitempty"`
	// Types that are valid to be assigned to Payload:
	//
	//	*UartMessage_AckPayload
	//	*UartMessage_EchoPayload
	//	*UartMessage_VersionResponse
	//	*UartMessage_ClientInfoResponse
	//	*UartMessage_ClientInputResponse
	//	*UartMessage_OtaStart
	//	*UartMessage_OtaPayload
	//	*UartMessage_OtaEnd
	//	*UartMessage_OtaStatus
	//	*UartMessage_AccelDeadzoneRequest
	//	*UartMessage_AccelDeadzoneResponse
	//	*UartMessage_EspnowUnicastTestRequest
	//	*UartMessage_EspnowUnicastTestResponse
	//	*UartMessage_OtaSlaveProgressRequest
	//	*UartMessage_OtaSlaveProgressResponse
	//	*UartMessage_LedRingProgressRequest
	//	*UartMessage_LedRingProgressResponse
	Payload       isUartMessage_Payload `protobuf_oneof:"payload"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UartMessage) ProtoMessage() {}

func (x *UartMessage) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 UartMessage.ProtoReflect.Descriptor instead.
func (*UartMessage) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{0}
}

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

func (x *UartMessage) GetPayload() isUartMessage_Payload {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *UartMessage) GetAckPayload() *Ack {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_AckPayload); ok {
			return x.AckPayload
		}
	}
	return nil
}

func (x *UartMessage) GetEchoPayload() *EchoPayload {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_EchoPayload); ok {
			return x.EchoPayload
		}
	}
	return nil
}

func (x *UartMessage) GetVersionResponse() *VersionResponse {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_VersionResponse); ok {
			return x.VersionResponse
		}
	}
	return nil
}

func (x *UartMessage) GetClientInfoResponse() *ClientInfoResponse {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_ClientInfoResponse); ok {
			return x.ClientInfoResponse
		}
	}
	return nil
}

func (x *UartMessage) GetClientInputResponse() *ClientInputResponse {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_ClientInputResponse); ok {
			return x.ClientInputResponse
		}
	}
	return nil
}

func (x *UartMessage) GetOtaStart() *OtaStartPayload {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_OtaStart); ok {
			return x.OtaStart
		}
	}
	return nil
}

func (x *UartMessage) GetOtaPayload() *OtaPayload {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_OtaPayload); ok {
			return x.OtaPayload
		}
	}
	return nil
}

func (x *UartMessage) GetOtaEnd() *OtaEndPayload {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_OtaEnd); ok {
			return x.OtaEnd
		}
	}
	return nil
}

func (x *UartMessage) GetOtaStatus() *OtaStatusPayload {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_OtaStatus); ok {
			return x.OtaStatus
		}
	}
	return nil
}

func (x *UartMessage) GetAccelDeadzoneRequest() *AccelDeadzoneRequest {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_AccelDeadzoneRequest); ok {
			return x.AccelDeadzoneRequest
		}
	}
	return nil
}

func (x *UartMessage) GetAccelDeadzoneResponse() *AccelDeadzoneResponse {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_AccelDeadzoneResponse); ok {
			return x.AccelDeadzoneResponse
		}
	}
	return nil
}

func (x *UartMessage) GetEspnowUnicastTestRequest() *EspNowUnicastTestRequest {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_EspnowUnicastTestRequest); ok {
			return x.EspnowUnicastTestRequest
		}
	}
	return nil
}

func (x *UartMessage) GetEspnowUnicastTestResponse() *EspNowUnicastTestResponse {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_EspnowUnicastTestResponse); ok {
			return x.EspnowUnicastTestResponse
		}
	}
	return nil
}

func (x *UartMessage) GetOtaSlaveProgressRequest() *OtaSlaveProgressRequest {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_OtaSlaveProgressRequest); ok {
			return x.OtaSlaveProgressRequest
		}
	}
	return nil
}

func (x *UartMessage) GetOtaSlaveProgressResponse() *OtaSlaveProgressResponse {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_OtaSlaveProgressResponse); ok {
			return x.OtaSlaveProgressResponse
		}
	}
	return nil
}

func (x *UartMessage) GetLedRingProgressRequest() *LedRingProgressRequest {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_LedRingProgressRequest); ok {
			return x.LedRingProgressRequest
		}
	}
	return nil
}

func (x *UartMessage) GetLedRingProgressResponse() *LedRingProgressResponse {
	if x != nil {
		if x, ok := x.Payload.(*UartMessage_LedRingProgressResponse); ok {
			return x.LedRingProgressResponse
		}
	}
	return nil
}

type isUartMessage_Payload interface {
	isUartMessage_Payload()
}

type UartMessage_AckPayload struct {
	AckPayload *Ack `protobuf:"bytes,2,opt,name=ack_payload,json=ackPayload,proto3,oneof"`
}

type UartMessage_EchoPayload struct {
	EchoPayload *EchoPayload `protobuf:"bytes,3,opt,name=echo_payload,json=echoPayload,proto3,oneof"`
}

type UartMessage_VersionResponse struct {
	VersionResponse *VersionResponse `protobuf:"bytes,4,opt,name=version_response,json=versionResponse,proto3,oneof"`
}

type UartMessage_ClientInfoResponse struct {
	ClientInfoResponse *ClientInfoResponse `protobuf:"bytes,5,opt,name=client_info_response,json=clientInfoResponse,proto3,oneof"`
}

type UartMessage_ClientInputResponse struct {
	ClientInputResponse *ClientInputResponse `protobuf:"bytes,6,opt,name=client_input_response,json=clientInputResponse,proto3,oneof"`
}

type UartMessage_OtaStart struct {
	OtaStart *OtaStartPayload `protobuf:"bytes,7,opt,name=ota_start,json=otaStart,proto3,oneof"`
}

type UartMessage_OtaPayload struct {
	OtaPayload *OtaPayload `protobuf:"bytes,8,opt,name=ota_payload,json=otaPayload,proto3,oneof"`
}

type UartMessage_OtaEnd struct {
	OtaEnd *OtaEndPayload `protobuf:"bytes,9,opt,name=ota_end,json=otaEnd,proto3,oneof"`
}

type UartMessage_OtaStatus struct {
	OtaStatus *OtaStatusPayload `protobuf:"bytes,10,opt,name=ota_status,json=otaStatus,proto3,oneof"`
}

type UartMessage_AccelDeadzoneRequest struct {
	AccelDeadzoneRequest *AccelDeadzoneRequest `protobuf:"bytes,11,opt,name=accel_deadzone_request,json=accelDeadzoneRequest,proto3,oneof"`
}

type UartMessage_AccelDeadzoneResponse struct {
	AccelDeadzoneResponse *AccelDeadzoneResponse `protobuf:"bytes,12,opt,name=accel_deadzone_response,json=accelDeadzoneResponse,proto3,oneof"`
}

type UartMessage_EspnowUnicastTestRequest struct {
	EspnowUnicastTestRequest *EspNowUnicastTestRequest `protobuf:"bytes,13,opt,name=espnow_unicast_test_request,json=espnowUnicastTestRequest,proto3,oneof"`
}

type UartMessage_EspnowUnicastTestResponse struct {
	EspnowUnicastTestResponse *EspNowUnicastTestResponse `protobuf:"bytes,14,opt,name=espnow_unicast_test_response,json=espnowUnicastTestResponse,proto3,oneof"`
}

type UartMessage_OtaSlaveProgressRequest struct {
	OtaSlaveProgressRequest *OtaSlaveProgressRequest `protobuf:"bytes,15,opt,name=ota_slave_progress_request,json=otaSlaveProgressRequest,proto3,oneof"`
}

type UartMessage_OtaSlaveProgressResponse struct {
	OtaSlaveProgressResponse *OtaSlaveProgressResponse `protobuf:"bytes,16,opt,name=ota_slave_progress_response,json=otaSlaveProgressResponse,proto3,oneof"`
}

type UartMessage_LedRingProgressRequest struct {
	LedRingProgressRequest *LedRingProgressRequest `protobuf:"bytes,17,opt,name=led_ring_progress_request,json=ledRingProgressRequest,proto3,oneof"`
}

type UartMessage_LedRingProgressResponse struct {
	LedRingProgressResponse *LedRingProgressResponse `protobuf:"bytes,18,opt,name=led_ring_progress_response,json=ledRingProgressResponse,proto3,oneof"`
}

func (*UartMessage_AckPayload) isUartMessage_Payload() {}

func (*UartMessage_EchoPayload) isUartMessage_Payload() {}

func (*UartMessage_VersionResponse) isUartMessage_Payload() {}

func (*UartMessage_ClientInfoResponse) isUartMessage_Payload() {}

func (*UartMessage_ClientInputResponse) isUartMessage_Payload() {}

func (*UartMessage_OtaStart) isUartMessage_Payload() {}

func (*UartMessage_OtaPayload) isUartMessage_Payload() {}

func (*UartMessage_OtaEnd) isUartMessage_Payload() {}

func (*UartMessage_OtaStatus) isUartMessage_Payload() {}

func (*UartMessage_AccelDeadzoneRequest) isUartMessage_Payload() {}

func (*UartMessage_AccelDeadzoneResponse) isUartMessage_Payload() {}

func (*UartMessage_EspnowUnicastTestRequest) isUartMessage_Payload() {}

func (*UartMessage_EspnowUnicastTestResponse) isUartMessage_Payload() {}

func (*UartMessage_OtaSlaveProgressRequest) isUartMessage_Payload() {}

func (*UartMessage_OtaSlaveProgressResponse) isUartMessage_Payload() {}

func (*UartMessage_LedRingProgressRequest) isUartMessage_Payload() {}

func (*UartMessage_LedRingProgressResponse) isUartMessage_Payload() {}

type Ack struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Ack) ProtoMessage() {}

func (x *Ack) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 Ack.ProtoReflect.Descriptor instead.
func (*Ack) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{1}
}

type EchoPayload struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EchoPayload) ProtoMessage() {}

func (x *EchoPayload) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 EchoPayload.ProtoReflect.Descriptor instead.
func (*EchoPayload) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{2}
}

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

type VersionResponse struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	Version uint32                 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	GitHash string                 `protobuf:"bytes,2,opt,name=git_hash,json=gitHash,proto3" json:"git_hash,omitempty"`
	// * Active OTA app partition label, e.g. "ota_0" or "ota_1".
	RunningPartition string `protobuf:"bytes,3,opt,name=running_partition,json=runningPartition,proto3" json:"running_partition,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*VersionResponse) ProtoMessage() {}

func (x *VersionResponse) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 VersionResponse.ProtoReflect.Descriptor instead.
func (*VersionResponse) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{3}
}

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

func (x *VersionResponse) GetGitHash() string {
	if x != nil {
		return x.GitHash
	}
	return ""
}

func (x *VersionResponse) GetRunningPartition() string {
	if x != nil {
		return x.RunningPartition
	}
	return ""
}

type ClientInfo struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Id              uint32                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Available       bool                   `protobuf:"varint,2,opt,name=available,proto3" json:"available,omitempty"`
	Used            bool                   `protobuf:"varint,3,opt,name=used,proto3" json:"used,omitempty"`
	Mac             []byte                 `protobuf:"bytes,4,opt,name=mac,proto3" json:"mac,omitempty"`
	LastPing        uint32                 `protobuf:"varint,5,opt,name=last_ping,json=lastPing,proto3" json:"last_ping,omitempty"`
	LastSuccessPing uint32                 `protobuf:"varint,6,opt,name=last_success_ping,json=lastSuccessPing,proto3" json:"last_success_ping,omitempty"`
	Version         uint32                 `protobuf:"varint,7,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*ClientInfo) ProtoMessage() {}

func (x *ClientInfo) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 ClientInfo.ProtoReflect.Descriptor instead.
func (*ClientInfo) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{4}
}

func (x *ClientInfo) GetId() uint32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *ClientInfo) GetAvailable() bool {
	if x != nil {
		return x.Available
	}
	return false
}

func (x *ClientInfo) GetUsed() bool {
	if x != nil {
		return x.Used
	}
	return false
}

func (x *ClientInfo) GetMac() []byte {
	if x != nil {
		return x.Mac
	}
	return nil
}

func (x *ClientInfo) GetLastPing() uint32 {
	if x != nil {
		return x.LastPing
	}
	return 0
}

func (x *ClientInfo) GetLastSuccessPing() uint32 {
	if x != nil {
		return x.LastSuccessPing
	}
	return 0
}

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

type ClientInfoResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Clients       []*ClientInfo          `protobuf:"bytes,1,rep,name=clients,proto3" json:"clients,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ClientInfoResponse) ProtoMessage() {}

func (x *ClientInfoResponse) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 ClientInfoResponse.ProtoReflect.Descriptor instead.
func (*ClientInfoResponse) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{5}
}

func (x *ClientInfoResponse) GetClients() []*ClientInfo {
	if x != nil {
		return x.Clients
	}
	return nil
}

type ClientInput struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            uint32                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	LageX         float32                `protobuf:"fixed32,2,opt,name=lage_x,json=lageX,proto3" json:"lage_x,omitempty"`
	LageY         float32                `protobuf:"fixed32,3,opt,name=lage_y,json=lageY,proto3" json:"lage_y,omitempty"`
	Bitmask       uint32                 `protobuf:"varint,4,opt,name=bitmask,proto3" json:"bitmask,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ClientInput) ProtoMessage() {}

func (x *ClientInput) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 ClientInput.ProtoReflect.Descriptor instead.
func (*ClientInput) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{6}
}

func (x *ClientInput) GetId() uint32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *ClientInput) GetLageX() float32 {
	if x != nil {
		return x.LageX
	}
	return 0
}

func (x *ClientInput) GetLageY() float32 {
	if x != nil {
		return x.LageY
	}
	return 0
}

func (x *ClientInput) GetBitmask() uint32 {
	if x != nil {
		return x.Bitmask
	}
	return 0
}

type ClientInputResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Clients       []*ClientInput         `protobuf:"bytes,1,rep,name=clients,proto3" json:"clients,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ClientInputResponse) ProtoMessage() {}

func (x *ClientInputResponse) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 ClientInputResponse.ProtoReflect.Descriptor instead.
func (*ClientInputResponse) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{7}
}

func (x *ClientInputResponse) GetClients() []*ClientInput {
	if x != nil {
		return x.Clients
	}
	return nil
}

// write=false: read deadzone; write=true: apply deadzone (LSB per axis, raw accel units).
// client_id 0 = local BMA456 on this node; >0 = slave id on master; ignored on slave.
// all_clients = true (master only): push deadzone to every registered slave via ESP-NOW.
type AccelDeadzoneRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Write         bool                   `protobuf:"varint,1,opt,name=write,proto3" json:"write,omitempty"`
	Deadzone      uint32                 `protobuf:"varint,2,opt,name=deadzone,proto3" json:"deadzone,omitempty"`
	ClientId      uint32                 `protobuf:"varint,3,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	AllClients    bool                   `protobuf:"varint,4,opt,name=all_clients,json=allClients,proto3" json:"all_clients,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AccelDeadzoneRequest) ProtoMessage() {}

func (x *AccelDeadzoneRequest) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 AccelDeadzoneRequest.ProtoReflect.Descriptor instead.
func (*AccelDeadzoneRequest) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{8}
}

func (x *AccelDeadzoneRequest) GetWrite() bool {
	if x != nil {
		return x.Write
	}
	return false
}

func (x *AccelDeadzoneRequest) GetDeadzone() uint32 {
	if x != nil {
		return x.Deadzone
	}
	return 0
}

func (x *AccelDeadzoneRequest) GetClientId() uint32 {
	if x != nil {
		return x.ClientId
	}
	return 0
}

func (x *AccelDeadzoneRequest) GetAllClients() bool {
	if x != nil {
		return x.AllClients
	}
	return false
}

type AccelDeadzoneResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Deadzone      uint32                 `protobuf:"varint,1,opt,name=deadzone,proto3" json:"deadzone,omitempty"`
	ClientId      uint32                 `protobuf:"varint,2,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	Success       bool                   `protobuf:"varint,3,opt,name=success,proto3" json:"success,omitempty"`
	SlavesUpdated uint32                 `protobuf:"varint,4,opt,name=slaves_updated,json=slavesUpdated,proto3" json:"slaves_updated,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AccelDeadzoneResponse) ProtoMessage() {}

func (x *AccelDeadzoneResponse) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 AccelDeadzoneResponse.ProtoReflect.Descriptor instead.
func (*AccelDeadzoneResponse) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{9}
}

func (x *AccelDeadzoneResponse) GetDeadzone() uint32 {
	if x != nil {
		return x.Deadzone
	}
	return 0
}

func (x *AccelDeadzoneResponse) GetClientId() uint32 {
	if x != nil {
		return x.ClientId
	}
	return 0
}

func (x *AccelDeadzoneResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *AccelDeadzoneResponse) GetSlavesUpdated() uint32 {
	if x != nil {
		return x.SlavesUpdated
	}
	return 0
}

type EspNowUnicastTestRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ClientId      uint32                 `protobuf:"varint,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	Seq           uint32                 `protobuf:"varint,2,opt,name=seq,proto3" json:"seq,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EspNowUnicastTestRequest) ProtoMessage() {}

func (x *EspNowUnicastTestRequest) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 EspNowUnicastTestRequest.ProtoReflect.Descriptor instead.
func (*EspNowUnicastTestRequest) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{10}
}

func (x *EspNowUnicastTestRequest) GetClientId() uint32 {
	if x != nil {
		return x.ClientId
	}
	return 0
}

func (x *EspNowUnicastTestRequest) GetSeq() uint32 {
	if x != nil {
		return x.Seq
	}
	return 0
}

type EspNowUnicastTestResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Seq           uint32                 `protobuf:"varint,2,opt,name=seq,proto3" json:"seq,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EspNowUnicastTestResponse) ProtoMessage() {}

func (x *EspNowUnicastTestResponse) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 EspNowUnicastTestResponse.ProtoReflect.Descriptor instead.
func (*EspNowUnicastTestResponse) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{11}
}

func (x *EspNowUnicastTestResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *EspNowUnicastTestResponse) GetSeq() uint32 {
	if x != nil {
		return x.Seq
	}
	return 0
}

// Host → device: LED ring display (progress bar, digit, or clear).
// mode: 0=clear, 1=progress (0–100 %), 2=digit (0–10, same layout as firmware digit maps).
type LedRingProgressRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Mode  uint32                 `protobuf:"varint,1,opt,name=mode,proto3" json:"mode,omitempty"`
	// * 0–100: fraction of ring LEDs to light (mode=progress)
	Progress uint32 `protobuf:"varint,2,opt,name=progress,proto3" json:"progress,omitempty"`
	// * 0–10 (mode=digit)
	Digit uint32 `protobuf:"varint,3,opt,name=digit,proto3" json:"digit,omitempty"`
	R     uint32 `protobuf:"varint,4,opt,name=r,proto3" json:"r,omitempty"`
	G     uint32 `protobuf:"varint,5,opt,name=g,proto3" json:"g,omitempty"`
	B     uint32 `protobuf:"varint,6,opt,name=b,proto3" json:"b,omitempty"`
	// * 0–255 brightness scale applied to r/g/b
	Intensity     uint32 `protobuf:"varint,7,opt,name=intensity,proto3" json:"intensity,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LedRingProgressRequest) ProtoMessage() {}

func (x *LedRingProgressRequest) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_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 LedRingProgressRequest.ProtoReflect.Descriptor instead.
func (*LedRingProgressRequest) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{12}
}

func (x *LedRingProgressRequest) GetMode() uint32 {
	if x != nil {
		return x.Mode
	}
	return 0
}

func (x *LedRingProgressRequest) GetProgress() uint32 {
	if x != nil {
		return x.Progress
	}
	return 0
}

func (x *LedRingProgressRequest) GetDigit() uint32 {
	if x != nil {
		return x.Digit
	}
	return 0
}

func (x *LedRingProgressRequest) GetR() uint32 {
	if x != nil {
		return x.R
	}
	return 0
}

func (x *LedRingProgressRequest) GetG() uint32 {
	if x != nil {
		return x.G
	}
	return 0
}

func (x *LedRingProgressRequest) GetB() uint32 {
	if x != nil {
		return x.B
	}
	return 0
}

func (x *LedRingProgressRequest) GetIntensity() uint32 {
	if x != nil {
		return x.Intensity
	}
	return 0
}

type LedRingProgressResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Mode          uint32                 `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"`
	Progress      uint32                 `protobuf:"varint,3,opt,name=progress,proto3" json:"progress,omitempty"`
	Digit         uint32                 `protobuf:"varint,4,opt,name=digit,proto3" json:"digit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LedRingProgressResponse) Reset() {
	*x = LedRingProgressResponse{}
	mi := &file_uart_messages_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*LedRingProgressResponse) ProtoMessage() {}

func (x *LedRingProgressResponse) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_proto_msgTypes[13]
	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 LedRingProgressResponse.ProtoReflect.Descriptor instead.
func (*LedRingProgressResponse) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{13}
}

func (x *LedRingProgressResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *LedRingProgressResponse) GetMode() uint32 {
	if x != nil {
		return x.Mode
	}
	return 0
}

func (x *LedRingProgressResponse) GetProgress() uint32 {
	if x != nil {
		return x.Progress
	}
	return 0
}

func (x *LedRingProgressResponse) GetDigit() uint32 {
	if x != nil {
		return x.Digit
	}
	return 0
}

// Host → device: begin UART OTA (erase inactive OTA slot; device replies OTA_STATUS).
type OtaStartPayload struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TotalSize     uint32                 `protobuf:"varint,1,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OtaStartPayload) Reset() {
	*x = OtaStartPayload{}
	mi := &file_uart_messages_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OtaStartPayload) ProtoMessage() {}

func (x *OtaStartPayload) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_proto_msgTypes[14]
	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 OtaStartPayload.ProtoReflect.Descriptor instead.
func (*OtaStartPayload) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{14}
}

func (x *OtaStartPayload) GetTotalSize() uint32 {
	if x != nil {
		return x.TotalSize
	}
	return 0
}

// Host → device: firmware chunk (up to 200 bytes); device buffers 4 KiB before flash write.
type OtaPayload struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Seq           uint32                 `protobuf:"varint,1,opt,name=seq,proto3" json:"seq,omitempty"`
	Data          []byte                 `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OtaPayload) Reset() {
	*x = OtaPayload{}
	mi := &file_uart_messages_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OtaPayload) ProtoMessage() {}

func (x *OtaPayload) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_proto_msgTypes[15]
	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 OtaPayload.ProtoReflect.Descriptor instead.
func (*OtaPayload) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{15}
}

func (x *OtaPayload) GetSeq() uint32 {
	if x != nil {
		return x.Seq
	}
	return 0
}

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

// Host → device: no more payload; device flushes buffer and finalizes OTA.
type OtaEndPayload struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OtaEndPayload) Reset() {
	*x = OtaEndPayload{}
	mi := &file_uart_messages_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OtaEndPayload) ProtoMessage() {}

func (x *OtaEndPayload) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_proto_msgTypes[16]
	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 OtaEndPayload.ProtoReflect.Descriptor instead.
func (*OtaEndPayload) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{16}
}

// Device → host status (also used as ACK after each 4 KiB written).
// status: 1=preparing, 2=ready, 3=block_ack, 4=success, 5=failed, 6=distributing
type OtaStatusPayload struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        uint32                 `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	BytesWritten  uint32                 `protobuf:"varint,2,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"`
	TargetSlot    uint32                 `protobuf:"varint,3,opt,name=target_slot,json=targetSlot,proto3" json:"target_slot,omitempty"`
	Error         uint32                 `protobuf:"varint,4,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OtaStatusPayload) Reset() {
	*x = OtaStatusPayload{}
	mi := &file_uart_messages_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OtaStatusPayload) ProtoMessage() {}

func (x *OtaStatusPayload) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_proto_msgTypes[17]
	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 OtaStatusPayload.ProtoReflect.Descriptor instead.
func (*OtaStatusPayload) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{17}
}

func (x *OtaStatusPayload) GetStatus() uint32 {
	if x != nil {
		return x.Status
	}
	return 0
}

func (x *OtaStatusPayload) GetBytesWritten() uint32 {
	if x != nil {
		return x.BytesWritten
	}
	return 0
}

func (x *OtaStatusPayload) GetTargetSlot() uint32 {
	if x != nil {
		return x.TargetSlot
	}
	return 0
}

func (x *OtaStatusPayload) GetError() uint32 {
	if x != nil {
		return x.Error
	}
	return 0
}

// Host → master: query ESP-NOW slave OTA progress (client_id 0 = all slaves in session).
type OtaSlaveProgressRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ClientId      uint32                 `protobuf:"varint,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OtaSlaveProgressRequest) Reset() {
	*x = OtaSlaveProgressRequest{}
	mi := &file_uart_messages_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OtaSlaveProgressRequest) ProtoMessage() {}

func (x *OtaSlaveProgressRequest) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_proto_msgTypes[18]
	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 OtaSlaveProgressRequest.ProtoReflect.Descriptor instead.
func (*OtaSlaveProgressRequest) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{18}
}

func (x *OtaSlaveProgressRequest) GetClientId() uint32 {
	if x != nil {
		return x.ClientId
	}
	return 0
}

type OtaSlaveProgressEntry struct {
	state        protoimpl.MessageState `protogen:"open.v1"`
	ClientId     uint32                 `protobuf:"varint,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	BytesWritten uint32                 `protobuf:"varint,2,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"`
	TotalBytes   uint32                 `protobuf:"varint,3,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"`
	// * 0=idle, 1=preparing, 2=ready, 3=distributing, 4=success, 5=failed
	Status        uint32 `protobuf:"varint,4,opt,name=status,proto3" json:"status,omitempty"`
	Error         uint32 `protobuf:"varint,5,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OtaSlaveProgressEntry) Reset() {
	*x = OtaSlaveProgressEntry{}
	mi := &file_uart_messages_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OtaSlaveProgressEntry) ProtoMessage() {}

func (x *OtaSlaveProgressEntry) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_proto_msgTypes[19]
	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 OtaSlaveProgressEntry.ProtoReflect.Descriptor instead.
func (*OtaSlaveProgressEntry) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{19}
}

func (x *OtaSlaveProgressEntry) GetClientId() uint32 {
	if x != nil {
		return x.ClientId
	}
	return 0
}

func (x *OtaSlaveProgressEntry) GetBytesWritten() uint32 {
	if x != nil {
		return x.BytesWritten
	}
	return 0
}

func (x *OtaSlaveProgressEntry) GetTotalBytes() uint32 {
	if x != nil {
		return x.TotalBytes
	}
	return 0
}

func (x *OtaSlaveProgressEntry) GetStatus() uint32 {
	if x != nil {
		return x.Status
	}
	return 0
}

func (x *OtaSlaveProgressEntry) GetError() uint32 {
	if x != nil {
		return x.Error
	}
	return 0
}

type OtaSlaveProgressResponse struct {
	state          protoimpl.MessageState   `protogen:"open.v1"`
	Active         bool                     `protobuf:"varint,1,opt,name=active,proto3" json:"active,omitempty"`
	TotalBytes     uint32                   `protobuf:"varint,2,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"`
	AggregateBytes uint32                   `protobuf:"varint,3,opt,name=aggregate_bytes,json=aggregateBytes,proto3" json:"aggregate_bytes,omitempty"`
	SlaveCount     uint32                   `protobuf:"varint,4,opt,name=slave_count,json=slaveCount,proto3" json:"slave_count,omitempty"`
	Slaves         []*OtaSlaveProgressEntry `protobuf:"bytes,5,rep,name=slaves,proto3" json:"slaves,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *OtaSlaveProgressResponse) Reset() {
	*x = OtaSlaveProgressResponse{}
	mi := &file_uart_messages_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OtaSlaveProgressResponse) ProtoMessage() {}

func (x *OtaSlaveProgressResponse) ProtoReflect() protoreflect.Message {
	mi := &file_uart_messages_proto_msgTypes[20]
	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 OtaSlaveProgressResponse.ProtoReflect.Descriptor instead.
func (*OtaSlaveProgressResponse) Descriptor() ([]byte, []int) {
	return file_uart_messages_proto_rawDescGZIP(), []int{20}
}

func (x *OtaSlaveProgressResponse) GetActive() bool {
	if x != nil {
		return x.Active
	}
	return false
}

func (x *OtaSlaveProgressResponse) GetTotalBytes() uint32 {
	if x != nil {
		return x.TotalBytes
	}
	return 0
}

func (x *OtaSlaveProgressResponse) GetAggregateBytes() uint32 {
	if x != nil {
		return x.AggregateBytes
	}
	return 0
}

func (x *OtaSlaveProgressResponse) GetSlaveCount() uint32 {
	if x != nil {
		return x.SlaveCount
	}
	return 0
}

func (x *OtaSlaveProgressResponse) GetSlaves() []*OtaSlaveProgressEntry {
	if x != nil {
		return x.Slaves
	}
	return nil
}

var File_uart_messages_proto protoreflect.FileDescriptor

const file_uart_messages_proto_rawDesc = "" +
	"\n" +
	"\x13uart_messages.proto\x12\x04alox\x1a\fnanopb.proto\"\xc4\n" +
	"\n" +
	"\vUartMessage\x12%\n" +
	"\x04type\x18\x01 \x01(\x0e2\x11.alox.MessageTypeR\x04type\x12,\n" +
	"\vack_payload\x18\x02 \x01(\v2\t.alox.AckH\x00R\n" +
	"ackPayload\x126\n" +
	"\fecho_payload\x18\x03 \x01(\v2\x11.alox.EchoPayloadH\x00R\vechoPayload\x12B\n" +
	"\x10version_response\x18\x04 \x01(\v2\x15.alox.VersionResponseH\x00R\x0fversionResponse\x12L\n" +
	"\x14client_info_response\x18\x05 \x01(\v2\x18.alox.ClientInfoResponseH\x00R\x12clientInfoResponse\x12O\n" +
	"\x15client_input_response\x18\x06 \x01(\v2\x19.alox.ClientInputResponseH\x00R\x13clientInputResponse\x124\n" +
	"\tota_start\x18\a \x01(\v2\x15.alox.OtaStartPayloadH\x00R\botaStart\x123\n" +
	"\vota_payload\x18\b \x01(\v2\x10.alox.OtaPayloadH\x00R\n" +
	"otaPayload\x12.\n" +
	"\aota_end\x18\t \x01(\v2\x13.alox.OtaEndPayloadH\x00R\x06otaEnd\x127\n" +
	"\n" +
	"ota_status\x18\n" +
	" \x01(\v2\x16.alox.OtaStatusPayloadH\x00R\totaStatus\x12R\n" +
	"\x16accel_deadzone_request\x18\v \x01(\v2\x1a.alox.AccelDeadzoneRequestH\x00R\x14accelDeadzoneRequest\x12U\n" +
	"\x17accel_deadzone_response\x18\f \x01(\v2\x1b.alox.AccelDeadzoneResponseH\x00R\x15accelDeadzoneResponse\x12_\n" +
	"\x1bespnow_unicast_test_request\x18\r \x01(\v2\x1e.alox.EspNowUnicastTestRequestH\x00R\x18espnowUnicastTestRequest\x12b\n" +
	"\x1cespnow_unicast_test_response\x18\x0e \x01(\v2\x1f.alox.EspNowUnicastTestResponseH\x00R\x19espnowUnicastTestResponse\x12\\\n" +
	"\x1aota_slave_progress_request\x18\x0f \x01(\v2\x1d.alox.OtaSlaveProgressRequestH\x00R\x17otaSlaveProgressRequest\x12_\n" +
	"\x1bota_slave_progress_response\x18\x10 \x01(\v2\x1e.alox.OtaSlaveProgressResponseH\x00R\x18otaSlaveProgressResponse\x12Y\n" +
	"\x19led_ring_progress_request\x18\x11 \x01(\v2\x1c.alox.LedRingProgressRequestH\x00R\x16ledRingProgressRequest\x12\\\n" +
	"\x1aled_ring_progress_response\x18\x12 \x01(\v2\x1d.alox.LedRingProgressResponseH\x00R\x17ledRingProgressResponseB\t\n" +
	"\apayload\"\x05\n" +
	"\x03Ack\"!\n" +
	"\vEchoPayload\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"s\n" +
	"\x0fVersionResponse\x12\x18\n" +
	"\aversion\x18\x01 \x01(\rR\aversion\x12\x19\n" +
	"\bgit_hash\x18\x02 \x01(\tR\agitHash\x12+\n" +
	"\x11running_partition\x18\x03 \x01(\tR\x10runningPartition\"\xc3\x01\n" +
	"\n" +
	"ClientInfo\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\rR\x02id\x12\x1c\n" +
	"\tavailable\x18\x02 \x01(\bR\tavailable\x12\x12\n" +
	"\x04used\x18\x03 \x01(\bR\x04used\x12\x10\n" +
	"\x03mac\x18\x04 \x01(\fR\x03mac\x12\x1b\n" +
	"\tlast_ping\x18\x05 \x01(\rR\blastPing\x12*\n" +
	"\x11last_success_ping\x18\x06 \x01(\rR\x0flastSuccessPing\x12\x18\n" +
	"\aversion\x18\a \x01(\rR\aversion\"@\n" +
	"\x12ClientInfoResponse\x12*\n" +
	"\aclients\x18\x01 \x03(\v2\x10.alox.ClientInfoR\aclients\"e\n" +
	"\vClientInput\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\rR\x02id\x12\x15\n" +
	"\x06lage_x\x18\x02 \x01(\x02R\x05lageX\x12\x15\n" +
	"\x06lage_y\x18\x03 \x01(\x02R\x05lageY\x12\x18\n" +
	"\abitmask\x18\x04 \x01(\rR\abitmask\"B\n" +
	"\x13ClientInputResponse\x12+\n" +
	"\aclients\x18\x01 \x03(\v2\x11.alox.ClientInputR\aclients\"\x86\x01\n" +
	"\x14AccelDeadzoneRequest\x12\x14\n" +
	"\x05write\x18\x01 \x01(\bR\x05write\x12\x1a\n" +
	"\bdeadzone\x18\x02 \x01(\rR\bdeadzone\x12\x1b\n" +
	"\tclient_id\x18\x03 \x01(\rR\bclientId\x12\x1f\n" +
	"\vall_clients\x18\x04 \x01(\bR\n" +
	"allClients\"\x91\x01\n" +
	"\x15AccelDeadzoneResponse\x12\x1a\n" +
	"\bdeadzone\x18\x01 \x01(\rR\bdeadzone\x12\x1b\n" +
	"\tclient_id\x18\x02 \x01(\rR\bclientId\x12\x18\n" +
	"\asuccess\x18\x03 \x01(\bR\asuccess\x12%\n" +
	"\x0eslaves_updated\x18\x04 \x01(\rR\rslavesUpdated\"I\n" +
	"\x18EspNowUnicastTestRequest\x12\x1b\n" +
	"\tclient_id\x18\x01 \x01(\rR\bclientId\x12\x10\n" +
	"\x03seq\x18\x02 \x01(\rR\x03seq\"G\n" +
	"\x19EspNowUnicastTestResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x10\n" +
	"\x03seq\x18\x02 \x01(\rR\x03seq\"\xa6\x01\n" +
	"\x16LedRingProgressRequest\x12\x12\n" +
	"\x04mode\x18\x01 \x01(\rR\x04mode\x12\x1a\n" +
	"\bprogress\x18\x02 \x01(\rR\bprogress\x12\x14\n" +
	"\x05digit\x18\x03 \x01(\rR\x05digit\x12\f\n" +
	"\x01r\x18\x04 \x01(\rR\x01r\x12\f\n" +
	"\x01g\x18\x05 \x01(\rR\x01g\x12\f\n" +
	"\x01b\x18\x06 \x01(\rR\x01b\x12\x1c\n" +
	"\tintensity\x18\a \x01(\rR\tintensity\"y\n" +
	"\x17LedRingProgressResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x12\n" +
	"\x04mode\x18\x02 \x01(\rR\x04mode\x12\x1a\n" +
	"\bprogress\x18\x03 \x01(\rR\bprogress\x12\x14\n" +
	"\x05digit\x18\x04 \x01(\rR\x05digit\"0\n" +
	"\x0fOtaStartPayload\x12\x1d\n" +
	"\n" +
	"total_size\x18\x01 \x01(\rR\ttotalSize\":\n" +
	"\n" +
	"OtaPayload\x12\x10\n" +
	"\x03seq\x18\x01 \x01(\rR\x03seq\x12\x1a\n" +
	"\x04data\x18\x02 \x01(\fB\x06\x92?\x03\b\xc8\x01R\x04data\"\x0f\n" +
	"\rOtaEndPayload\"\x86\x01\n" +
	"\x10OtaStatusPayload\x12\x16\n" +
	"\x06status\x18\x01 \x01(\rR\x06status\x12#\n" +
	"\rbytes_written\x18\x02 \x01(\rR\fbytesWritten\x12\x1f\n" +
	"\vtarget_slot\x18\x03 \x01(\rR\n" +
	"targetSlot\x12\x14\n" +
	"\x05error\x18\x04 \x01(\rR\x05error\"6\n" +
	"\x17OtaSlaveProgressRequest\x12\x1b\n" +
	"\tclient_id\x18\x01 \x01(\rR\bclientId\"\xa8\x01\n" +
	"\x15OtaSlaveProgressEntry\x12\x1b\n" +
	"\tclient_id\x18\x01 \x01(\rR\bclientId\x12#\n" +
	"\rbytes_written\x18\x02 \x01(\rR\fbytesWritten\x12\x1f\n" +
	"\vtotal_bytes\x18\x03 \x01(\rR\n" +
	"totalBytes\x12\x16\n" +
	"\x06status\x18\x04 \x01(\rR\x06status\x12\x14\n" +
	"\x05error\x18\x05 \x01(\rR\x05error\"\xd9\x01\n" +
	"\x18OtaSlaveProgressResponse\x12\x16\n" +
	"\x06active\x18\x01 \x01(\bR\x06active\x12\x1f\n" +
	"\vtotal_bytes\x18\x02 \x01(\rR\n" +
	"totalBytes\x12'\n" +
	"\x0faggregate_bytes\x18\x03 \x01(\rR\x0eaggregateBytes\x12\x1f\n" +
	"\vslave_count\x18\x04 \x01(\rR\n" +
	"slaveCount\x12:\n" +
	"\x06slaves\x18\x05 \x03(\v2\x1b.alox.OtaSlaveProgressEntryB\x05\x92?\x02\x10\x10R\x06slaves*\x83\x02\n" +
	"\vMessageType\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\a\n" +
	"\x03ACK\x10\x01\x12\b\n" +
	"\x04ECHO\x10\x02\x12\v\n" +
	"\aVERSION\x10\x03\x12\x0f\n" +
	"\vCLIENT_INFO\x10\x04\x12\x10\n" +
	"\fCLIENT_INPUT\x10\x05\x12\x12\n" +
	"\x0eACCEL_DEADZONE\x10\x06\x12\x17\n" +
	"\x13ESPNOW_UNICAST_TEST\x10\a\x12\f\n" +
	"\bLED_RING\x10\b\x12\r\n" +
	"\tOTA_START\x10\x10\x12\x0f\n" +
	"\vOTA_PAYLOAD\x10\x11\x12\v\n" +
	"\aOTA_END\x10\x12\x12\x0e\n" +
	"\n" +
	"OTA_STATUS\x10\x13\x12\x14\n" +
	"\x10OTA_START_ESPNOW\x10\x14\x12\x16\n" +
	"\x12OTA_SLAVE_PROGRESS\x10\x15b\x06proto3"

var (
	file_uart_messages_proto_rawDescOnce sync.Once
	file_uart_messages_proto_rawDescData []byte
)

func file_uart_messages_proto_rawDescGZIP() []byte {
	file_uart_messages_proto_rawDescOnce.Do(func() {
		file_uart_messages_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_uart_messages_proto_rawDesc), len(file_uart_messages_proto_rawDesc)))
	})
	return file_uart_messages_proto_rawDescData
}

var file_uart_messages_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_uart_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 21)
var file_uart_messages_proto_goTypes = []any{
	(MessageType)(0),                  // 0: alox.MessageType
	(*UartMessage)(nil),               // 1: alox.UartMessage
	(*Ack)(nil),                       // 2: alox.Ack
	(*EchoPayload)(nil),               // 3: alox.EchoPayload
	(*VersionResponse)(nil),           // 4: alox.VersionResponse
	(*ClientInfo)(nil),                // 5: alox.ClientInfo
	(*ClientInfoResponse)(nil),        // 6: alox.ClientInfoResponse
	(*ClientInput)(nil),               // 7: alox.ClientInput
	(*ClientInputResponse)(nil),       // 8: alox.ClientInputResponse
	(*AccelDeadzoneRequest)(nil),      // 9: alox.AccelDeadzoneRequest
	(*AccelDeadzoneResponse)(nil),     // 10: alox.AccelDeadzoneResponse
	(*EspNowUnicastTestRequest)(nil),  // 11: alox.EspNowUnicastTestRequest
	(*EspNowUnicastTestResponse)(nil), // 12: alox.EspNowUnicastTestResponse
	(*LedRingProgressRequest)(nil),    // 13: alox.LedRingProgressRequest
	(*LedRingProgressResponse)(nil),   // 14: alox.LedRingProgressResponse
	(*OtaStartPayload)(nil),           // 15: alox.OtaStartPayload
	(*OtaPayload)(nil),                // 16: alox.OtaPayload
	(*OtaEndPayload)(nil),             // 17: alox.OtaEndPayload
	(*OtaStatusPayload)(nil),          // 18: alox.OtaStatusPayload
	(*OtaSlaveProgressRequest)(nil),   // 19: alox.OtaSlaveProgressRequest
	(*OtaSlaveProgressEntry)(nil),     // 20: alox.OtaSlaveProgressEntry
	(*OtaSlaveProgressResponse)(nil),  // 21: alox.OtaSlaveProgressResponse
}
var file_uart_messages_proto_depIdxs = []int32{
	0,  // 0: alox.UartMessage.type:type_name -> alox.MessageType
	2,  // 1: alox.UartMessage.ack_payload:type_name -> alox.Ack
	3,  // 2: alox.UartMessage.echo_payload:type_name -> alox.EchoPayload
	4,  // 3: alox.UartMessage.version_response:type_name -> alox.VersionResponse
	6,  // 4: alox.UartMessage.client_info_response:type_name -> alox.ClientInfoResponse
	8,  // 5: alox.UartMessage.client_input_response:type_name -> alox.ClientInputResponse
	15, // 6: alox.UartMessage.ota_start:type_name -> alox.OtaStartPayload
	16, // 7: alox.UartMessage.ota_payload:type_name -> alox.OtaPayload
	17, // 8: alox.UartMessage.ota_end:type_name -> alox.OtaEndPayload
	18, // 9: alox.UartMessage.ota_status:type_name -> alox.OtaStatusPayload
	9,  // 10: alox.UartMessage.accel_deadzone_request:type_name -> alox.AccelDeadzoneRequest
	10, // 11: alox.UartMessage.accel_deadzone_response:type_name -> alox.AccelDeadzoneResponse
	11, // 12: alox.UartMessage.espnow_unicast_test_request:type_name -> alox.EspNowUnicastTestRequest
	12, // 13: alox.UartMessage.espnow_unicast_test_response:type_name -> alox.EspNowUnicastTestResponse
	19, // 14: alox.UartMessage.ota_slave_progress_request:type_name -> alox.OtaSlaveProgressRequest
	21, // 15: alox.UartMessage.ota_slave_progress_response:type_name -> alox.OtaSlaveProgressResponse
	13, // 16: alox.UartMessage.led_ring_progress_request:type_name -> alox.LedRingProgressRequest
	14, // 17: alox.UartMessage.led_ring_progress_response:type_name -> alox.LedRingProgressResponse
	5,  // 18: alox.ClientInfoResponse.clients:type_name -> alox.ClientInfo
	7,  // 19: alox.ClientInputResponse.clients:type_name -> alox.ClientInput
	20, // 20: alox.OtaSlaveProgressResponse.slaves:type_name -> alox.OtaSlaveProgressEntry
	21, // [21:21] is the sub-list for method output_type
	21, // [21:21] is the sub-list for method input_type
	21, // [21:21] is the sub-list for extension type_name
	21, // [21:21] is the sub-list for extension extendee
	0,  // [0:21] is the sub-list for field type_name
}

func init() { file_uart_messages_proto_init() }
func file_uart_messages_proto_init() {
	if File_uart_messages_proto != nil {
		return
	}
	file_uart_messages_proto_msgTypes[0].OneofWrappers = []any{
		(*UartMessage_AckPayload)(nil),
		(*UartMessage_EchoPayload)(nil),
		(*UartMessage_VersionResponse)(nil),
		(*UartMessage_ClientInfoResponse)(nil),
		(*UartMessage_ClientInputResponse)(nil),
		(*UartMessage_OtaStart)(nil),
		(*UartMessage_OtaPayload)(nil),
		(*UartMessage_OtaEnd)(nil),
		(*UartMessage_OtaStatus)(nil),
		(*UartMessage_AccelDeadzoneRequest)(nil),
		(*UartMessage_AccelDeadzoneResponse)(nil),
		(*UartMessage_EspnowUnicastTestRequest)(nil),
		(*UartMessage_EspnowUnicastTestResponse)(nil),
		(*UartMessage_OtaSlaveProgressRequest)(nil),
		(*UartMessage_OtaSlaveProgressResponse)(nil),
		(*UartMessage_LedRingProgressRequest)(nil),
		(*UartMessage_LedRingProgressResponse)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_uart_messages_proto_rawDesc), len(file_uart_messages_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   21,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_uart_messages_proto_goTypes,
		DependencyIndexes: file_uart_messages_proto_depIdxs,
		EnumInfos:         file_uart_messages_proto_enumTypes,
		MessageInfos:      file_uart_messages_proto_msgTypes,
	}.Build()
	File_uart_messages_proto = out.File
	file_uart_messages_proto_goTypes = nil
	file_uart_messages_proto_depIdxs = nil
}