// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v5.29.3
// source: path/protocol/shannon.proto

package protocol

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	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)
)

// ShannonRequestErrorType enumerates possible relay request errors.
type ShannonRequestErrorType int32

const (
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_UNSPECIFIED ShannonRequestErrorType = 0
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL    ShannonRequestErrorType = 1 // Internal error.
	// No endpoints available for the service
	// Due to one or more of the following:
	// - Any of the gateway mode errors above
	// - Error fetching a session for one or more apps.
	// - One or more available endpoints are sanctioned.
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_NO_ENDPOINTS_AVAILABLE ShannonRequestErrorType = 2
	// Centralized gateway mode: Error fetching the app.
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_APP_FETCH_ERR ShannonRequestErrorType = 3
	// Centralized gateway mode app does not delegate to the gateway.
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_APP_DELEGATION ShannonRequestErrorType = 4
	// Centralized gateway mode: no active sessions found for service.
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_NO_SESSIONS ShannonRequestErrorType = 5
	// Centralized gateway mode: no apps found for service.
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_NO_APPS_FOR_SERVICE ShannonRequestErrorType = 6
	// Delegated gateway mode: could not extract app address from HTTP request
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_GET_APP_HTTP ShannonRequestErrorType = 7
	// Delegated gateway mode: error fetching the app
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_FETCH_APP ShannonRequestErrorType = 8
	// Delegated gateway mode: app does not delegate to the gateway
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_APP_DOES_NOT_DELEGATE ShannonRequestErrorType = 9
	// Error initializing a signer for the selected gateway mode.
	ShannonRequestErrorType_SHANNON_REQUEST_ERROR_INTERNAL_SIGNER_SETUP_ERROR ShannonRequestErrorType = 10
)

// Enum value maps for ShannonRequestErrorType.
var (
	ShannonRequestErrorType_name = map[int32]string{
		0:  "SHANNON_REQUEST_ERROR_UNSPECIFIED",
		1:  "SHANNON_REQUEST_ERROR_INTERNAL",
		2:  "SHANNON_REQUEST_ERROR_INTERNAL_NO_ENDPOINTS_AVAILABLE",
		3:  "SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_APP_FETCH_ERR",
		4:  "SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_APP_DELEGATION",
		5:  "SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_NO_SESSIONS",
		6:  "SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_NO_APPS_FOR_SERVICE",
		7:  "SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_GET_APP_HTTP",
		8:  "SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_FETCH_APP",
		9:  "SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_APP_DOES_NOT_DELEGATE",
		10: "SHANNON_REQUEST_ERROR_INTERNAL_SIGNER_SETUP_ERROR",
	}
	ShannonRequestErrorType_value = map[string]int32{
		"SHANNON_REQUEST_ERROR_UNSPECIFIED":                                   0,
		"SHANNON_REQUEST_ERROR_INTERNAL":                                      1,
		"SHANNON_REQUEST_ERROR_INTERNAL_NO_ENDPOINTS_AVAILABLE":               2,
		"SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_APP_FETCH_ERR":       3,
		"SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_APP_DELEGATION":      4,
		"SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_NO_SESSIONS":         5,
		"SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_NO_APPS_FOR_SERVICE": 6,
		"SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_GET_APP_HTTP":               7,
		"SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_FETCH_APP":                  8,
		"SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_APP_DOES_NOT_DELEGATE":      9,
		"SHANNON_REQUEST_ERROR_INTERNAL_SIGNER_SETUP_ERROR":                   10,
	}
)

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

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

func (ShannonRequestErrorType) Descriptor() protoreflect.EnumDescriptor {
	return file_path_protocol_shannon_proto_enumTypes[0].Descriptor()
}

func (ShannonRequestErrorType) Type() protoreflect.EnumType {
	return &file_path_protocol_shannon_proto_enumTypes[0]
}

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

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

// ShannonEndpointErrorType enumerates possible relay errors when interacting with Shannon endpoints.
type ShannonEndpointErrorType int32

const (
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_UNSPECIFIED ShannonEndpointErrorType = 0
	// endpoint internal error: not recognized.
	// DEPRECATED: Use more specific error types below (HTTP_UNKNOWN, RAW_PAYLOAD_UNKNOWN, UNKNOWN)
	//
	// Deprecated: Marked as deprecated in path/protocol/shannon.proto.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_INTERNAL ShannonEndpointErrorType = 1
	// endpoint config error: e.g. DNS lookup error, TLS certificate error.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_CONFIG ShannonEndpointErrorType = 2
	// endpoint timeout on responding to relay request.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_TIMEOUT ShannonEndpointErrorType = 3
	// Endpoint payload failed to unmarshal into a RelayResponse struct
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_PAYLOAD_UNMARSHAL_ERR ShannonEndpointErrorType = 4
	// Endpoint response failed basic validation
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RESPONSE_VALIDATION_ERR ShannonEndpointErrorType = 5
	// Could not fetch the public key for supplier address used for the relay.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RESPONSE_GET_PUBKEY_ERR ShannonEndpointErrorType = 6
	// Received nil public key on supplier lookup using its address
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_NIL_SUPPLIER_PUBKEY ShannonEndpointErrorType = 7
	// RelayResponse's signature failed validation.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RESPONSE_SIGNATURE_VALIDATION_ERR ShannonEndpointErrorType = 8
	// HTTP relay errors - fine-grained network and transport failures
	// Connection establishment failures
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_REFUSED  ShannonEndpointErrorType = 10
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_RESET    ShannonEndpointErrorType = 11
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_TIMEOUT  ShannonEndpointErrorType = 12
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_NO_ROUTE_TO_HOST    ShannonEndpointErrorType = 13
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_NETWORK_UNREACHABLE ShannonEndpointErrorType = 14
	// Transport layer errors
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_BROKEN_PIPE     ShannonEndpointErrorType = 15
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_IO_TIMEOUT      ShannonEndpointErrorType = 16
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_TRANSPORT_ERROR ShannonEndpointErrorType = 17
	// HTTP protocol errors
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_BAD_RESPONSE   ShannonEndpointErrorType = 18
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_INVALID_STATUS ShannonEndpointErrorType = 19
	// Raw payload analysis error types (when unmarshal/validation fails)
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_CONNECTION_REFUSED       ShannonEndpointErrorType = 20
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SERVICE_NOT_CONFIGURED   ShannonEndpointErrorType = 21
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_UNEXPECTED_EOF           ShannonEndpointErrorType = 22
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_PROTOCOL_WIRE_TYPE       ShannonEndpointErrorType = 23
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_PROTOCOL_RELAY_REQUEST   ShannonEndpointErrorType = 24
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SUPPLIERS_NOT_REACHABLE  ShannonEndpointErrorType = 25
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_BACKEND_SERVICE          ShannonEndpointErrorType = 26
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_TCP_CONNECTION           ShannonEndpointErrorType = 27
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RESPONSE_SIZE_EXCEEDED   ShannonEndpointErrorType = 28
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SERVER_CLOSED_CONNECTION ShannonEndpointErrorType = 29
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_HTTP_TRANSPORT           ShannonEndpointErrorType = 30
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_DNS_RESOLUTION           ShannonEndpointErrorType = 31
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_TLS_HANDSHAKE            ShannonEndpointErrorType = 32
	// RelayRequest was canceled by PATH intentionally.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_REQUEST_CANCELED_BY_PATH ShannonEndpointErrorType = 33
	// ** SHANNON_ENDPOINT_ERROR_HTTP_UNKNOWN **
	// PATH -> HTTP Request -> Endpoint
	// HTTP Response is NOT received
	// We cannot move forward with PATH business logic
	// There is nothing to go to.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_UNKNOWN        ShannonEndpointErrorType = 34
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_UNKNOWN ShannonEndpointErrorType = 35
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_UNKNOWN             ShannonEndpointErrorType = 36
	// The relay request sent to the endpoint via HTTP returned a non 2XX HTTP status code.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_NON_2XX_STATUS ShannonEndpointErrorType = 37
	// The relay request sent to the endpoint via HTTP failed with `context deadline exceeded` error
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONTEXT_DEADLINE_EXCEEDED ShannonEndpointErrorType = 38
	// The relay request sent to the endpoint via Websocket failed to establish a connection.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_WEBSOCKET_CONNECTION_FAILED ShannonEndpointErrorType = 39
	// The relay request sent to the endpoint via Websocket failed to sign the request.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_WEBSOCKET_REQUEST_SIGNING_FAILED ShannonEndpointErrorType = 40
	// The relay request sent to the endpoint via Websocket failed to validate the relay response.
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_WEBSOCKET_RELAY_RESPONSE_VALIDATION_FAILED ShannonEndpointErrorType = 41
	// RelayMiner returned a 4XX HTTP status code
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_4XX ShannonEndpointErrorType = 42
	// RelayMiner returned a 5XX HTTP status code
	ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_5XX ShannonEndpointErrorType = 43
)

// Enum value maps for ShannonEndpointErrorType.
var (
	ShannonEndpointErrorType_name = map[int32]string{
		0:  "SHANNON_ENDPOINT_ERROR_UNSPECIFIED",
		1:  "SHANNON_ENDPOINT_ERROR_INTERNAL",
		2:  "SHANNON_ENDPOINT_ERROR_CONFIG",
		3:  "SHANNON_ENDPOINT_ERROR_TIMEOUT",
		4:  "SHANNON_ENDPOINT_ERROR_PAYLOAD_UNMARSHAL_ERR",
		5:  "SHANNON_ENDPOINT_ERROR_RESPONSE_VALIDATION_ERR",
		6:  "SHANNON_ENDPOINT_ERROR_RESPONSE_GET_PUBKEY_ERR",
		7:  "SHANNON_ENDPOINT_ERROR_NIL_SUPPLIER_PUBKEY",
		8:  "SHANNON_ENDPOINT_ERROR_RESPONSE_SIGNATURE_VALIDATION_ERR",
		10: "SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_REFUSED",
		11: "SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_RESET",
		12: "SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_TIMEOUT",
		13: "SHANNON_ENDPOINT_ERROR_HTTP_NO_ROUTE_TO_HOST",
		14: "SHANNON_ENDPOINT_ERROR_HTTP_NETWORK_UNREACHABLE",
		15: "SHANNON_ENDPOINT_ERROR_HTTP_BROKEN_PIPE",
		16: "SHANNON_ENDPOINT_ERROR_HTTP_IO_TIMEOUT",
		17: "SHANNON_ENDPOINT_ERROR_HTTP_TRANSPORT_ERROR",
		18: "SHANNON_ENDPOINT_ERROR_HTTP_BAD_RESPONSE",
		19: "SHANNON_ENDPOINT_ERROR_HTTP_INVALID_STATUS",
		20: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_CONNECTION_REFUSED",
		21: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SERVICE_NOT_CONFIGURED",
		22: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_UNEXPECTED_EOF",
		23: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_PROTOCOL_WIRE_TYPE",
		24: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_PROTOCOL_RELAY_REQUEST",
		25: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SUPPLIERS_NOT_REACHABLE",
		26: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_BACKEND_SERVICE",
		27: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_TCP_CONNECTION",
		28: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RESPONSE_SIZE_EXCEEDED",
		29: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SERVER_CLOSED_CONNECTION",
		30: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_HTTP_TRANSPORT",
		31: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_DNS_RESOLUTION",
		32: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_TLS_HANDSHAKE",
		33: "SHANNON_ENDPOINT_REQUEST_CANCELED_BY_PATH",
		34: "SHANNON_ENDPOINT_ERROR_HTTP_UNKNOWN",
		35: "SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_UNKNOWN",
		36: "SHANNON_ENDPOINT_ERROR_UNKNOWN",
		37: "SHANNON_ENDPOINT_ERROR_HTTP_NON_2XX_STATUS",
		38: "SHANNON_ENDPOINT_ERROR_HTTP_CONTEXT_DEADLINE_EXCEEDED",
		39: "SHANNON_ENDPOINT_ERROR_WEBSOCKET_CONNECTION_FAILED",
		40: "SHANNON_ENDPOINT_ERROR_WEBSOCKET_REQUEST_SIGNING_FAILED",
		41: "SHANNON_ENDPOINT_ERROR_WEBSOCKET_RELAY_RESPONSE_VALIDATION_FAILED",
		42: "SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_4XX",
		43: "SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_5XX",
	}
	ShannonEndpointErrorType_value = map[string]int32{
		"SHANNON_ENDPOINT_ERROR_UNSPECIFIED":                                0,
		"SHANNON_ENDPOINT_ERROR_INTERNAL":                                   1,
		"SHANNON_ENDPOINT_ERROR_CONFIG":                                     2,
		"SHANNON_ENDPOINT_ERROR_TIMEOUT":                                    3,
		"SHANNON_ENDPOINT_ERROR_PAYLOAD_UNMARSHAL_ERR":                      4,
		"SHANNON_ENDPOINT_ERROR_RESPONSE_VALIDATION_ERR":                    5,
		"SHANNON_ENDPOINT_ERROR_RESPONSE_GET_PUBKEY_ERR":                    6,
		"SHANNON_ENDPOINT_ERROR_NIL_SUPPLIER_PUBKEY":                        7,
		"SHANNON_ENDPOINT_ERROR_RESPONSE_SIGNATURE_VALIDATION_ERR":          8,
		"SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_REFUSED":                    10,
		"SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_RESET":                      11,
		"SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_TIMEOUT":                    12,
		"SHANNON_ENDPOINT_ERROR_HTTP_NO_ROUTE_TO_HOST":                      13,
		"SHANNON_ENDPOINT_ERROR_HTTP_NETWORK_UNREACHABLE":                   14,
		"SHANNON_ENDPOINT_ERROR_HTTP_BROKEN_PIPE":                           15,
		"SHANNON_ENDPOINT_ERROR_HTTP_IO_TIMEOUT":                            16,
		"SHANNON_ENDPOINT_ERROR_HTTP_TRANSPORT_ERROR":                       17,
		"SHANNON_ENDPOINT_ERROR_HTTP_BAD_RESPONSE":                          18,
		"SHANNON_ENDPOINT_ERROR_HTTP_INVALID_STATUS":                        19,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_CONNECTION_REFUSED":             20,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SERVICE_NOT_CONFIGURED":         21,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_UNEXPECTED_EOF":                 22,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_PROTOCOL_WIRE_TYPE":             23,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_PROTOCOL_RELAY_REQUEST":         24,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SUPPLIERS_NOT_REACHABLE":        25,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_BACKEND_SERVICE":                26,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_TCP_CONNECTION":                 27,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RESPONSE_SIZE_EXCEEDED":         28,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SERVER_CLOSED_CONNECTION":       29,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_HTTP_TRANSPORT":                 30,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_DNS_RESOLUTION":                 31,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_TLS_HANDSHAKE":                  32,
		"SHANNON_ENDPOINT_REQUEST_CANCELED_BY_PATH":                         33,
		"SHANNON_ENDPOINT_ERROR_HTTP_UNKNOWN":                               34,
		"SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_UNKNOWN":                        35,
		"SHANNON_ENDPOINT_ERROR_UNKNOWN":                                    36,
		"SHANNON_ENDPOINT_ERROR_HTTP_NON_2XX_STATUS":                        37,
		"SHANNON_ENDPOINT_ERROR_HTTP_CONTEXT_DEADLINE_EXCEEDED":             38,
		"SHANNON_ENDPOINT_ERROR_WEBSOCKET_CONNECTION_FAILED":                39,
		"SHANNON_ENDPOINT_ERROR_WEBSOCKET_REQUEST_SIGNING_FAILED":           40,
		"SHANNON_ENDPOINT_ERROR_WEBSOCKET_RELAY_RESPONSE_VALIDATION_FAILED": 41,
		"SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_4XX":                       42,
		"SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_5XX":                       43,
	}
)

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

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

func (ShannonEndpointErrorType) Descriptor() protoreflect.EnumDescriptor {
	return file_path_protocol_shannon_proto_enumTypes[1].Descriptor()
}

func (ShannonEndpointErrorType) Type() protoreflect.EnumType {
	return &file_path_protocol_shannon_proto_enumTypes[1]
}

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

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

// ShannonSanctionType specifies the duration type for endpoint sanctions
type ShannonSanctionType int32

const (
	ShannonSanctionType_SHANNON_SANCTION_UNSPECIFIED     ShannonSanctionType = 0
	ShannonSanctionType_SHANNON_SANCTION_SESSION         ShannonSanctionType = 1 // Valid only for current session
	ShannonSanctionType_SHANNON_SANCTION_PERMANENT       ShannonSanctionType = 2 // Sanction persists indefinitely; can only be cleared by Gateway restart (e.g., redeploying the K8s pod or restarting the binary)
	ShannonSanctionType_SHANNON_SANCTION_DO_NOT_SANCTION ShannonSanctionType = 3 // Do not sanction the endpoint based on this error
)

// Enum value maps for ShannonSanctionType.
var (
	ShannonSanctionType_name = map[int32]string{
		0: "SHANNON_SANCTION_UNSPECIFIED",
		1: "SHANNON_SANCTION_SESSION",
		2: "SHANNON_SANCTION_PERMANENT",
		3: "SHANNON_SANCTION_DO_NOT_SANCTION",
	}
	ShannonSanctionType_value = map[string]int32{
		"SHANNON_SANCTION_UNSPECIFIED":     0,
		"SHANNON_SANCTION_SESSION":         1,
		"SHANNON_SANCTION_PERMANENT":       2,
		"SHANNON_SANCTION_DO_NOT_SANCTION": 3,
	}
)

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

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

func (ShannonSanctionType) Descriptor() protoreflect.EnumDescriptor {
	return file_path_protocol_shannon_proto_enumTypes[2].Descriptor()
}

func (ShannonSanctionType) Type() protoreflect.EnumType {
	return &file_path_protocol_shannon_proto_enumTypes[2]
}

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

// Deprecated: Use ShannonSanctionType.Descriptor instead.
func (ShannonSanctionType) EnumDescriptor() ([]byte, []int) {
	return file_path_protocol_shannon_proto_rawDescGZIP(), []int{2}
}

// Connection event type to distinguish between establishment and closure
type ShannonWebsocketConnectionObservation_ConnectionEventType int32

const (
	ShannonWebsocketConnectionObservation_CONNECTION_EVENT_TYPE_UNSPECIFIED ShannonWebsocketConnectionObservation_ConnectionEventType = 0
	ShannonWebsocketConnectionObservation_CONNECTION_ESTABLISHED            ShannonWebsocketConnectionObservation_ConnectionEventType = 1
	ShannonWebsocketConnectionObservation_CONNECTION_CLOSED                 ShannonWebsocketConnectionObservation_ConnectionEventType = 2
	ShannonWebsocketConnectionObservation_CONNECTION_ESTABLISHMENT_FAILED   ShannonWebsocketConnectionObservation_ConnectionEventType = 3
)

// Enum value maps for ShannonWebsocketConnectionObservation_ConnectionEventType.
var (
	ShannonWebsocketConnectionObservation_ConnectionEventType_name = map[int32]string{
		0: "CONNECTION_EVENT_TYPE_UNSPECIFIED",
		1: "CONNECTION_ESTABLISHED",
		2: "CONNECTION_CLOSED",
		3: "CONNECTION_ESTABLISHMENT_FAILED",
	}
	ShannonWebsocketConnectionObservation_ConnectionEventType_value = map[string]int32{
		"CONNECTION_EVENT_TYPE_UNSPECIFIED": 0,
		"CONNECTION_ESTABLISHED":            1,
		"CONNECTION_CLOSED":                 2,
		"CONNECTION_ESTABLISHMENT_FAILED":   3,
	}
)

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

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

func (ShannonWebsocketConnectionObservation_ConnectionEventType) Descriptor() protoreflect.EnumDescriptor {
	return file_path_protocol_shannon_proto_enumTypes[3].Descriptor()
}

func (ShannonWebsocketConnectionObservation_ConnectionEventType) Type() protoreflect.EnumType {
	return &file_path_protocol_shannon_proto_enumTypes[3]
}

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

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

// ShannonRequestError stores details of any errors encountered processing the request.
type ShannonRequestError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Type of request error, e.g. internal
	ErrorType ShannonRequestErrorType `protobuf:"varint,1,opt,name=error_type,json=errorType,proto3,enum=path.protocol.ShannonRequestErrorType" json:"error_type,omitempty"`
	// Details of the request error.
	ErrorDetails  string `protobuf:"bytes,2,opt,name=error_details,json=errorDetails,proto3" json:"error_details,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ShannonRequestError) ProtoMessage() {}

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

func (x *ShannonRequestError) GetErrorType() ShannonRequestErrorType {
	if x != nil {
		return x.ErrorType
	}
	return ShannonRequestErrorType_SHANNON_REQUEST_ERROR_UNSPECIFIED
}

func (x *ShannonRequestError) GetErrorDetails() string {
	if x != nil {
		return x.ErrorDetails
	}
	return ""
}

// ShannonRelayMinerError captures relay miner error details from the RelayResponse
type ShannonRelayMinerError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Codespace from the RelayMinerError
	Codespace string `protobuf:"bytes,1,opt,name=codespace,proto3" json:"codespace,omitempty"`
	// Code from the RelayMinerError
	Code uint32 `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"`
	// Message from the RelayMinerError
	Message       string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ShannonRelayMinerError) ProtoMessage() {}

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

func (x *ShannonRelayMinerError) GetCodespace() string {
	if x != nil {
		return x.Codespace
	}
	return ""
}

func (x *ShannonRelayMinerError) GetCode() uint32 {
	if x != nil {
		return x.Code
	}
	return 0
}

func (x *ShannonRelayMinerError) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// ShannonWebsocketConnectionObservation stores observations from a Websocket connection lifecycle
type ShannonWebsocketConnectionObservation struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Supplier of the endpoint handling the Websocket connection
	Supplier string `protobuf:"bytes,1,opt,name=supplier,proto3" json:"supplier,omitempty"`
	// URL of the Websocket endpoint
	EndpointUrl string `protobuf:"bytes,2,opt,name=endpoint_url,json=endpointUrl,proto3" json:"endpoint_url,omitempty"`
	// Application address associated with the endpoint
	EndpointAppAddress string `protobuf:"bytes,3,opt,name=endpoint_app_address,json=endpointAppAddress,proto3" json:"endpoint_app_address,omitempty"`
	// Service ID of the session associated with the endpoint.
	SessionServiceId string `protobuf:"bytes,4,opt,name=session_service_id,json=sessionServiceId,proto3" json:"session_service_id,omitempty"`
	// Session ID of the session associated with the endpoint.
	SessionId string `protobuf:"bytes,5,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// session start height
	SessionStartHeight int64 `protobuf:"varint,6,opt,name=session_start_height,json=sessionStartHeight,proto3" json:"session_start_height,omitempty"`
	// session end height
	SessionEndHeight int64 `protobuf:"varint,7,opt,name=session_end_height,json=sessionEndHeight,proto3" json:"session_end_height,omitempty"`
	// Error type if Websocket connection establishment or operation failed
	ErrorType *ShannonEndpointErrorType `protobuf:"varint,8,opt,name=error_type,json=errorType,proto3,enum=path.protocol.ShannonEndpointErrorType,oneof" json:"error_type,omitempty"`
	// Additional error details when available
	ErrorDetails *string `protobuf:"bytes,9,opt,name=error_details,json=errorDetails,proto3,oneof" json:"error_details,omitempty"`
	// Recommended sanction type based on the error
	RecommendedSanction *ShannonSanctionType `protobuf:"varint,10,opt,name=recommended_sanction,json=recommendedSanction,proto3,enum=path.protocol.ShannonSanctionType,oneof" json:"recommended_sanction,omitempty"`
	// Tracks whether the endpoint is a fallback endpoint
	IsFallbackEndpoint bool `protobuf:"varint,11,opt,name=is_fallback_endpoint,json=isFallbackEndpoint,proto3" json:"is_fallback_endpoint,omitempty"`
	// Connection lifecycle timestamps
	ConnectionEstablishedTimestamp *timestamppb.Timestamp                                    `protobuf:"bytes,12,opt,name=connection_established_timestamp,json=connectionEstablishedTimestamp,proto3" json:"connection_established_timestamp,omitempty"`
	ConnectionClosedTimestamp      *timestamppb.Timestamp                                    `protobuf:"bytes,13,opt,name=connection_closed_timestamp,json=connectionClosedTimestamp,proto3,oneof" json:"connection_closed_timestamp,omitempty"`
	EventType                      ShannonWebsocketConnectionObservation_ConnectionEventType `protobuf:"varint,14,opt,name=event_type,json=eventType,proto3,enum=path.protocol.ShannonWebsocketConnectionObservation_ConnectionEventType" json:"event_type,omitempty"`
	unknownFields                  protoimpl.UnknownFields
	sizeCache                      protoimpl.SizeCache
}

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

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

func (*ShannonWebsocketConnectionObservation) ProtoMessage() {}

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

func (x *ShannonWebsocketConnectionObservation) GetSupplier() string {
	if x != nil {
		return x.Supplier
	}
	return ""
}

func (x *ShannonWebsocketConnectionObservation) GetEndpointUrl() string {
	if x != nil {
		return x.EndpointUrl
	}
	return ""
}

func (x *ShannonWebsocketConnectionObservation) GetEndpointAppAddress() string {
	if x != nil {
		return x.EndpointAppAddress
	}
	return ""
}

func (x *ShannonWebsocketConnectionObservation) GetSessionServiceId() string {
	if x != nil {
		return x.SessionServiceId
	}
	return ""
}

func (x *ShannonWebsocketConnectionObservation) GetSessionId() string {
	if x != nil {
		return x.SessionId
	}
	return ""
}

func (x *ShannonWebsocketConnectionObservation) GetSessionStartHeight() int64 {
	if x != nil {
		return x.SessionStartHeight
	}
	return 0
}

func (x *ShannonWebsocketConnectionObservation) GetSessionEndHeight() int64 {
	if x != nil {
		return x.SessionEndHeight
	}
	return 0
}

func (x *ShannonWebsocketConnectionObservation) GetErrorType() ShannonEndpointErrorType {
	if x != nil && x.ErrorType != nil {
		return *x.ErrorType
	}
	return ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_UNSPECIFIED
}

func (x *ShannonWebsocketConnectionObservation) GetErrorDetails() string {
	if x != nil && x.ErrorDetails != nil {
		return *x.ErrorDetails
	}
	return ""
}

func (x *ShannonWebsocketConnectionObservation) GetRecommendedSanction() ShannonSanctionType {
	if x != nil && x.RecommendedSanction != nil {
		return *x.RecommendedSanction
	}
	return ShannonSanctionType_SHANNON_SANCTION_UNSPECIFIED
}

func (x *ShannonWebsocketConnectionObservation) GetIsFallbackEndpoint() bool {
	if x != nil {
		return x.IsFallbackEndpoint
	}
	return false
}

func (x *ShannonWebsocketConnectionObservation) GetConnectionEstablishedTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.ConnectionEstablishedTimestamp
	}
	return nil
}

func (x *ShannonWebsocketConnectionObservation) GetConnectionClosedTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.ConnectionClosedTimestamp
	}
	return nil
}

func (x *ShannonWebsocketConnectionObservation) GetEventType() ShannonWebsocketConnectionObservation_ConnectionEventType {
	if x != nil {
		return x.EventType
	}
	return ShannonWebsocketConnectionObservation_CONNECTION_EVENT_TYPE_UNSPECIFIED
}

// ShannonWebsocketMessageObservation stores observations from individual Websocket messages
type ShannonWebsocketMessageObservation struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Supplier of the endpoint handling the Websocket message
	Supplier string `protobuf:"bytes,1,opt,name=supplier,proto3" json:"supplier,omitempty"`
	// URL of the Websocket endpoint
	EndpointUrl string `protobuf:"bytes,2,opt,name=endpoint_url,json=endpointUrl,proto3" json:"endpoint_url,omitempty"`
	// Application address associated with the endpoint
	EndpointAppAddress string `protobuf:"bytes,3,opt,name=endpoint_app_address,json=endpointAppAddress,proto3" json:"endpoint_app_address,omitempty"`
	// Service ID of the session associated with the endpoint.
	SessionServiceId string `protobuf:"bytes,4,opt,name=session_service_id,json=sessionServiceId,proto3" json:"session_service_id,omitempty"`
	// Session ID of the session associated with the endpoint.
	SessionId string `protobuf:"bytes,5,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// session start height
	SessionStartHeight int64 `protobuf:"varint,6,opt,name=session_start_height,json=sessionStartHeight,proto3" json:"session_start_height,omitempty"`
	// session end height
	SessionEndHeight int64 `protobuf:"varint,7,opt,name=session_end_height,json=sessionEndHeight,proto3" json:"session_end_height,omitempty"`
	// Timestamp marking when the message was sent to the endpoint
	// For subscription events, this represents when the event was received from endpoint
	MessageTimestamp *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=message_timestamp,json=messageTimestamp,proto3" json:"message_timestamp,omitempty"`
	// Size of the message payload in bytes
	MessagePayloadSize int64 `protobuf:"varint,9,opt,name=message_payload_size,json=messagePayloadSize,proto3" json:"message_payload_size,omitempty"`
	// Error type if message processing failed
	ErrorType *ShannonEndpointErrorType `protobuf:"varint,10,opt,name=error_type,json=errorType,proto3,enum=path.protocol.ShannonEndpointErrorType,oneof" json:"error_type,omitempty"`
	// Additional error details when available
	ErrorDetails *string `protobuf:"bytes,11,opt,name=error_details,json=errorDetails,proto3,oneof" json:"error_details,omitempty"`
	// Recommended sanction type based on the error
	RecommendedSanction *ShannonSanctionType `protobuf:"varint,12,opt,name=recommended_sanction,json=recommendedSanction,proto3,enum=path.protocol.ShannonSanctionType,oneof" json:"recommended_sanction,omitempty"`
	// RelayMiner error details if the endpoint returned a RelayMinerError for this message
	RelayMinerError *ShannonRelayMinerError `protobuf:"bytes,13,opt,name=relay_miner_error,json=relayMinerError,proto3,oneof" json:"relay_miner_error,omitempty"`
	// Tracks whether the endpoint is a fallback endpoint
	IsFallbackEndpoint bool `protobuf:"varint,14,opt,name=is_fallback_endpoint,json=isFallbackEndpoint,proto3" json:"is_fallback_endpoint,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*ShannonWebsocketMessageObservation) ProtoMessage() {}

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

func (x *ShannonWebsocketMessageObservation) GetSupplier() string {
	if x != nil {
		return x.Supplier
	}
	return ""
}

func (x *ShannonWebsocketMessageObservation) GetEndpointUrl() string {
	if x != nil {
		return x.EndpointUrl
	}
	return ""
}

func (x *ShannonWebsocketMessageObservation) GetEndpointAppAddress() string {
	if x != nil {
		return x.EndpointAppAddress
	}
	return ""
}

func (x *ShannonWebsocketMessageObservation) GetSessionServiceId() string {
	if x != nil {
		return x.SessionServiceId
	}
	return ""
}

func (x *ShannonWebsocketMessageObservation) GetSessionId() string {
	if x != nil {
		return x.SessionId
	}
	return ""
}

func (x *ShannonWebsocketMessageObservation) GetSessionStartHeight() int64 {
	if x != nil {
		return x.SessionStartHeight
	}
	return 0
}

func (x *ShannonWebsocketMessageObservation) GetSessionEndHeight() int64 {
	if x != nil {
		return x.SessionEndHeight
	}
	return 0
}

func (x *ShannonWebsocketMessageObservation) GetMessageTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.MessageTimestamp
	}
	return nil
}

func (x *ShannonWebsocketMessageObservation) GetMessagePayloadSize() int64 {
	if x != nil {
		return x.MessagePayloadSize
	}
	return 0
}

func (x *ShannonWebsocketMessageObservation) GetErrorType() ShannonEndpointErrorType {
	if x != nil && x.ErrorType != nil {
		return *x.ErrorType
	}
	return ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_UNSPECIFIED
}

func (x *ShannonWebsocketMessageObservation) GetErrorDetails() string {
	if x != nil && x.ErrorDetails != nil {
		return *x.ErrorDetails
	}
	return ""
}

func (x *ShannonWebsocketMessageObservation) GetRecommendedSanction() ShannonSanctionType {
	if x != nil && x.RecommendedSanction != nil {
		return *x.RecommendedSanction
	}
	return ShannonSanctionType_SHANNON_SANCTION_UNSPECIFIED
}

func (x *ShannonWebsocketMessageObservation) GetRelayMinerError() *ShannonRelayMinerError {
	if x != nil {
		return x.RelayMinerError
	}
	return nil
}

func (x *ShannonWebsocketMessageObservation) GetIsFallbackEndpoint() bool {
	if x != nil {
		return x.IsFallbackEndpoint
	}
	return false
}

// ShannonRequestObservations represents observations collected during the processing
// of a single Shannon protocol relay request.
// Next free field: 6
type ShannonRequestObservations struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Service ID (i.e. chain ID) for which the observation was made
	ServiceId string `protobuf:"bytes,1,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
	// Error encountered processing the request, if any.
	RequestError *ShannonRequestError `protobuf:"bytes,2,opt,name=request_error,json=requestError,proto3,oneof" json:"request_error,omitempty"`
	// Observation data - exactly one of the following will be set
	//
	// Types that are valid to be assigned to ObservationData:
	//
	//	*ShannonRequestObservations_HttpObservations
	//	*ShannonRequestObservations_WebsocketConnectionObservation
	//	*ShannonRequestObservations_WebsocketMessageObservation
	ObservationData isShannonRequestObservations_ObservationData `protobuf_oneof:"observation_data"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*ShannonRequestObservations) ProtoMessage() {}

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

func (x *ShannonRequestObservations) GetServiceId() string {
	if x != nil {
		return x.ServiceId
	}
	return ""
}

func (x *ShannonRequestObservations) GetRequestError() *ShannonRequestError {
	if x != nil {
		return x.RequestError
	}
	return nil
}

func (x *ShannonRequestObservations) GetObservationData() isShannonRequestObservations_ObservationData {
	if x != nil {
		return x.ObservationData
	}
	return nil
}

func (x *ShannonRequestObservations) GetHttpObservations() *ShannonHTTPEndpointObservations {
	if x != nil {
		if x, ok := x.ObservationData.(*ShannonRequestObservations_HttpObservations); ok {
			return x.HttpObservations
		}
	}
	return nil
}

func (x *ShannonRequestObservations) GetWebsocketConnectionObservation() *ShannonWebsocketConnectionObservation {
	if x != nil {
		if x, ok := x.ObservationData.(*ShannonRequestObservations_WebsocketConnectionObservation); ok {
			return x.WebsocketConnectionObservation
		}
	}
	return nil
}

func (x *ShannonRequestObservations) GetWebsocketMessageObservation() *ShannonWebsocketMessageObservation {
	if x != nil {
		if x, ok := x.ObservationData.(*ShannonRequestObservations_WebsocketMessageObservation); ok {
			return x.WebsocketMessageObservation
		}
	}
	return nil
}

type isShannonRequestObservations_ObservationData interface {
	isShannonRequestObservations_ObservationData()
}

type ShannonRequestObservations_HttpObservations struct {
	// HTTP endpoint observations (multiple possible due to retries)
	HttpObservations *ShannonHTTPEndpointObservations `protobuf:"bytes,3,opt,name=http_observations,json=httpObservations,proto3,oneof"`
}

type ShannonRequestObservations_WebsocketConnectionObservation struct {
	// Single Websocket connection lifecycle observation
	WebsocketConnectionObservation *ShannonWebsocketConnectionObservation `protobuf:"bytes,4,opt,name=websocket_connection_observation,json=websocketConnectionObservation,proto3,oneof"`
}

type ShannonRequestObservations_WebsocketMessageObservation struct {
	// Single Websocket message observation
	WebsocketMessageObservation *ShannonWebsocketMessageObservation `protobuf:"bytes,5,opt,name=websocket_message_observation,json=websocketMessageObservation,proto3,oneof"`
}

func (*ShannonRequestObservations_HttpObservations) isShannonRequestObservations_ObservationData() {}

func (*ShannonRequestObservations_WebsocketConnectionObservation) isShannonRequestObservations_ObservationData() {
}

func (*ShannonRequestObservations_WebsocketMessageObservation) isShannonRequestObservations_ObservationData() {
}

// ShannonHTTPEndpointObservations wraps multiple HTTP endpoint observations
type ShannonHTTPEndpointObservations struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Multiple observations possible if:
	// - Original endpoint returns invalid response
	// - Retry mechanism activates
	EndpointObservations []*ShannonEndpointObservation `protobuf:"bytes,1,rep,name=endpoint_observations,json=endpointObservations,proto3" json:"endpoint_observations,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*ShannonHTTPEndpointObservations) ProtoMessage() {}

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

func (x *ShannonHTTPEndpointObservations) GetEndpointObservations() []*ShannonEndpointObservation {
	if x != nil {
		return x.EndpointObservations
	}
	return nil
}

// ShannonEndpointObservation stores a single observation from an endpoint
type ShannonEndpointObservation struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Supplier of the endpoint handling the request
	Supplier string `protobuf:"bytes,1,opt,name=supplier,proto3" json:"supplier,omitempty"`
	// URL of the endpoint handling the request
	EndpointUrl string `protobuf:"bytes,2,opt,name=endpoint_url,json=endpointUrl,proto3" json:"endpoint_url,omitempty"`
	// Application address associated with the endpoint
	EndpointAppAddress string `protobuf:"bytes,3,opt,name=endpoint_app_address,json=endpointAppAddress,proto3" json:"endpoint_app_address,omitempty"`
	// Service ID of the session associated with the endpoint.
	SessionServiceId string `protobuf:"bytes,4,opt,name=session_service_id,json=sessionServiceId,proto3" json:"session_service_id,omitempty"`
	// Session ID of the session associated with the endpoint.
	SessionId string `protobuf:"bytes,5,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// session start height
	SessionStartHeight int64 `protobuf:"varint,6,opt,name=session_start_height,json=sessionStartHeight,proto3" json:"session_start_height,omitempty"`
	// session end height
	SessionEndHeight int64 `protobuf:"varint,7,opt,name=session_end_height,json=sessionEndHeight,proto3" json:"session_end_height,omitempty"`
	// Timestamp marking the sending of the request to the endpoint.
	EndpointQueryTimestamp *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=endpoint_query_timestamp,json=endpointQueryTimestamp,proto3" json:"endpoint_query_timestamp,omitempty"`
	// Timestamp marking the reception of the endpoint's response.
	// Only set if the endpoint did not timeout.
	EndpointResponseTimestamp *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=endpoint_response_timestamp,json=endpointResponseTimestamp,proto3,oneof" json:"endpoint_response_timestamp,omitempty"`
	// Error type if relay to this endpoint failed
	ErrorType *ShannonEndpointErrorType `protobuf:"varint,10,opt,name=error_type,json=errorType,proto3,enum=path.protocol.ShannonEndpointErrorType,oneof" json:"error_type,omitempty"`
	// Additional error details when available
	ErrorDetails *string `protobuf:"bytes,11,opt,name=error_details,json=errorDetails,proto3,oneof" json:"error_details,omitempty"`
	// Recommended sanction type based on the error
	RecommendedSanction *ShannonSanctionType `protobuf:"varint,12,opt,name=recommended_sanction,json=recommendedSanction,proto3,enum=path.protocol.ShannonSanctionType,oneof" json:"recommended_sanction,omitempty"`
	// RelayMiner error details if the endpoint returned a RelayMinerError
	RelayMinerError *ShannonRelayMinerError `protobuf:"bytes,13,opt,name=relay_miner_error,json=relayMinerError,proto3,oneof" json:"relay_miner_error,omitempty"`
	// HTTP status code of the endpoint response
	EndpointBackendServiceHttpResponseStatusCode *int32 `protobuf:"varint,14,opt,name=endpoint_backend_service_http_response_status_code,json=endpointBackendServiceHttpResponseStatusCode,proto3,oneof" json:"endpoint_backend_service_http_response_status_code,omitempty"`
	// HTTP Response payload size
	EndpointBackendServiceHttpResponsePayloadSize *int64 `protobuf:"varint,15,opt,name=endpoint_backend_service_http_response_payload_size,json=endpointBackendServiceHttpResponsePayloadSize,proto3,oneof" json:"endpoint_backend_service_http_response_payload_size,omitempty"`
	// TODO_TECHDEBT(@adshmh): Separate fallback endpoints into a separate message:
	// Most of fields above (e.g. session_id) only apply to a Shannon endpoint.
	//
	// TODO_CONSIDERATION(@adshmh): Consider renaming to is_gateway_owned OR is_off_protocol.
	//
	// Tracks whether the endpoint is a fallback endpoint.
	IsFallbackEndpoint bool `protobuf:"varint,16,opt,name=is_fallback_endpoint,json=isFallbackEndpoint,proto3" json:"is_fallback_endpoint,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*ShannonEndpointObservation) ProtoMessage() {}

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

func (x *ShannonEndpointObservation) GetSupplier() string {
	if x != nil {
		return x.Supplier
	}
	return ""
}

func (x *ShannonEndpointObservation) GetEndpointUrl() string {
	if x != nil {
		return x.EndpointUrl
	}
	return ""
}

func (x *ShannonEndpointObservation) GetEndpointAppAddress() string {
	if x != nil {
		return x.EndpointAppAddress
	}
	return ""
}

func (x *ShannonEndpointObservation) GetSessionServiceId() string {
	if x != nil {
		return x.SessionServiceId
	}
	return ""
}

func (x *ShannonEndpointObservation) GetSessionId() string {
	if x != nil {
		return x.SessionId
	}
	return ""
}

func (x *ShannonEndpointObservation) GetSessionStartHeight() int64 {
	if x != nil {
		return x.SessionStartHeight
	}
	return 0
}

func (x *ShannonEndpointObservation) GetSessionEndHeight() int64 {
	if x != nil {
		return x.SessionEndHeight
	}
	return 0
}

func (x *ShannonEndpointObservation) GetEndpointQueryTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.EndpointQueryTimestamp
	}
	return nil
}

func (x *ShannonEndpointObservation) GetEndpointResponseTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.EndpointResponseTimestamp
	}
	return nil
}

func (x *ShannonEndpointObservation) GetErrorType() ShannonEndpointErrorType {
	if x != nil && x.ErrorType != nil {
		return *x.ErrorType
	}
	return ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_UNSPECIFIED
}

func (x *ShannonEndpointObservation) GetErrorDetails() string {
	if x != nil && x.ErrorDetails != nil {
		return *x.ErrorDetails
	}
	return ""
}

func (x *ShannonEndpointObservation) GetRecommendedSanction() ShannonSanctionType {
	if x != nil && x.RecommendedSanction != nil {
		return *x.RecommendedSanction
	}
	return ShannonSanctionType_SHANNON_SANCTION_UNSPECIFIED
}

func (x *ShannonEndpointObservation) GetRelayMinerError() *ShannonRelayMinerError {
	if x != nil {
		return x.RelayMinerError
	}
	return nil
}

func (x *ShannonEndpointObservation) GetEndpointBackendServiceHttpResponseStatusCode() int32 {
	if x != nil && x.EndpointBackendServiceHttpResponseStatusCode != nil {
		return *x.EndpointBackendServiceHttpResponseStatusCode
	}
	return 0
}

func (x *ShannonEndpointObservation) GetEndpointBackendServiceHttpResponsePayloadSize() int64 {
	if x != nil && x.EndpointBackendServiceHttpResponsePayloadSize != nil {
		return *x.EndpointBackendServiceHttpResponsePayloadSize
	}
	return 0
}

func (x *ShannonEndpointObservation) GetIsFallbackEndpoint() bool {
	if x != nil {
		return x.IsFallbackEndpoint
	}
	return false
}

// ShannonObservationsList provides a container for multiple ShannonRequestObservations,
// allowing them to be embedded in other protocol buffers.
type ShannonObservationsList struct {
	state         protoimpl.MessageState        `protogen:"open.v1"`
	Observations  []*ShannonRequestObservations `protobuf:"bytes,1,rep,name=observations,proto3" json:"observations,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ShannonObservationsList) ProtoMessage() {}

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

func (x *ShannonObservationsList) GetObservations() []*ShannonRequestObservations {
	if x != nil {
		return x.Observations
	}
	return nil
}

var File_path_protocol_shannon_proto protoreflect.FileDescriptor

const file_path_protocol_shannon_proto_rawDesc = "" +
	"\n" +
	"\x1bpath/protocol/shannon.proto\x12\rpath.protocol\x1a\x1fgoogle/protobuf/timestamp.proto\"\x81\x01\n" +
	"\x13ShannonRequestError\x12E\n" +
	"\n" +
	"error_type\x18\x01 \x01(\x0e2&.path.protocol.ShannonRequestErrorTypeR\terrorType\x12#\n" +
	"\rerror_details\x18\x02 \x01(\tR\ferrorDetails\"d\n" +
	"\x16ShannonRelayMinerError\x12\x1c\n" +
	"\tcodespace\x18\x01 \x01(\tR\tcodespace\x12\x12\n" +
	"\x04code\x18\x02 \x01(\rR\x04code\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\"\xeb\b\n" +
	"%ShannonWebsocketConnectionObservation\x12\x1a\n" +
	"\bsupplier\x18\x01 \x01(\tR\bsupplier\x12!\n" +
	"\fendpoint_url\x18\x02 \x01(\tR\vendpointUrl\x120\n" +
	"\x14endpoint_app_address\x18\x03 \x01(\tR\x12endpointAppAddress\x12,\n" +
	"\x12session_service_id\x18\x04 \x01(\tR\x10sessionServiceId\x12\x1d\n" +
	"\n" +
	"session_id\x18\x05 \x01(\tR\tsessionId\x120\n" +
	"\x14session_start_height\x18\x06 \x01(\x03R\x12sessionStartHeight\x12,\n" +
	"\x12session_end_height\x18\a \x01(\x03R\x10sessionEndHeight\x12K\n" +
	"\n" +
	"error_type\x18\b \x01(\x0e2'.path.protocol.ShannonEndpointErrorTypeH\x00R\terrorType\x88\x01\x01\x12(\n" +
	"\rerror_details\x18\t \x01(\tH\x01R\ferrorDetails\x88\x01\x01\x12Z\n" +
	"\x14recommended_sanction\x18\n" +
	" \x01(\x0e2\".path.protocol.ShannonSanctionTypeH\x02R\x13recommendedSanction\x88\x01\x01\x120\n" +
	"\x14is_fallback_endpoint\x18\v \x01(\bR\x12isFallbackEndpoint\x12d\n" +
	" connection_established_timestamp\x18\f \x01(\v2\x1a.google.protobuf.TimestampR\x1econnectionEstablishedTimestamp\x12_\n" +
	"\x1bconnection_closed_timestamp\x18\r \x01(\v2\x1a.google.protobuf.TimestampH\x03R\x19connectionClosedTimestamp\x88\x01\x01\x12g\n" +
	"\n" +
	"event_type\x18\x0e \x01(\x0e2H.path.protocol.ShannonWebsocketConnectionObservation.ConnectionEventTypeR\teventType\"\x94\x01\n" +
	"\x13ConnectionEventType\x12%\n" +
	"!CONNECTION_EVENT_TYPE_UNSPECIFIED\x10\x00\x12\x1a\n" +
	"\x16CONNECTION_ESTABLISHED\x10\x01\x12\x15\n" +
	"\x11CONNECTION_CLOSED\x10\x02\x12#\n" +
	"\x1fCONNECTION_ESTABLISHMENT_FAILED\x10\x03B\r\n" +
	"\v_error_typeB\x10\n" +
	"\x0e_error_detailsB\x17\n" +
	"\x15_recommended_sanctionB\x1e\n" +
	"\x1c_connection_closed_timestamp\"\xea\x06\n" +
	"\"ShannonWebsocketMessageObservation\x12\x1a\n" +
	"\bsupplier\x18\x01 \x01(\tR\bsupplier\x12!\n" +
	"\fendpoint_url\x18\x02 \x01(\tR\vendpointUrl\x120\n" +
	"\x14endpoint_app_address\x18\x03 \x01(\tR\x12endpointAppAddress\x12,\n" +
	"\x12session_service_id\x18\x04 \x01(\tR\x10sessionServiceId\x12\x1d\n" +
	"\n" +
	"session_id\x18\x05 \x01(\tR\tsessionId\x120\n" +
	"\x14session_start_height\x18\x06 \x01(\x03R\x12sessionStartHeight\x12,\n" +
	"\x12session_end_height\x18\a \x01(\x03R\x10sessionEndHeight\x12G\n" +
	"\x11message_timestamp\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\x10messageTimestamp\x120\n" +
	"\x14message_payload_size\x18\t \x01(\x03R\x12messagePayloadSize\x12K\n" +
	"\n" +
	"error_type\x18\n" +
	" \x01(\x0e2'.path.protocol.ShannonEndpointErrorTypeH\x00R\terrorType\x88\x01\x01\x12(\n" +
	"\rerror_details\x18\v \x01(\tH\x01R\ferrorDetails\x88\x01\x01\x12Z\n" +
	"\x14recommended_sanction\x18\f \x01(\x0e2\".path.protocol.ShannonSanctionTypeH\x02R\x13recommendedSanction\x88\x01\x01\x12V\n" +
	"\x11relay_miner_error\x18\r \x01(\v2%.path.protocol.ShannonRelayMinerErrorH\x03R\x0frelayMinerError\x88\x01\x01\x120\n" +
	"\x14is_fallback_endpoint\x18\x0e \x01(\bR\x12isFallbackEndpointB\r\n" +
	"\v_error_typeB\x10\n" +
	"\x0e_error_detailsB\x17\n" +
	"\x15_recommended_sanctionB\x14\n" +
	"\x12_relay_miner_error\"\x8a\x04\n" +
	"\x1aShannonRequestObservations\x12\x1d\n" +
	"\n" +
	"service_id\x18\x01 \x01(\tR\tserviceId\x12L\n" +
	"\rrequest_error\x18\x02 \x01(\v2\".path.protocol.ShannonRequestErrorH\x01R\frequestError\x88\x01\x01\x12]\n" +
	"\x11http_observations\x18\x03 \x01(\v2..path.protocol.ShannonHTTPEndpointObservationsH\x00R\x10httpObservations\x12\x80\x01\n" +
	" websocket_connection_observation\x18\x04 \x01(\v24.path.protocol.ShannonWebsocketConnectionObservationH\x00R\x1ewebsocketConnectionObservation\x12w\n" +
	"\x1dwebsocket_message_observation\x18\x05 \x01(\v21.path.protocol.ShannonWebsocketMessageObservationH\x00R\x1bwebsocketMessageObservationB\x12\n" +
	"\x10observation_dataB\x10\n" +
	"\x0e_request_error\"\x81\x01\n" +
	"\x1fShannonHTTPEndpointObservations\x12^\n" +
	"\x15endpoint_observations\x18\x01 \x03(\v2).path.protocol.ShannonEndpointObservationR\x14endpointObservations\"\x8d\n" +
	"\n" +
	"\x1aShannonEndpointObservation\x12\x1a\n" +
	"\bsupplier\x18\x01 \x01(\tR\bsupplier\x12!\n" +
	"\fendpoint_url\x18\x02 \x01(\tR\vendpointUrl\x120\n" +
	"\x14endpoint_app_address\x18\x03 \x01(\tR\x12endpointAppAddress\x12,\n" +
	"\x12session_service_id\x18\x04 \x01(\tR\x10sessionServiceId\x12\x1d\n" +
	"\n" +
	"session_id\x18\x05 \x01(\tR\tsessionId\x120\n" +
	"\x14session_start_height\x18\x06 \x01(\x03R\x12sessionStartHeight\x12,\n" +
	"\x12session_end_height\x18\a \x01(\x03R\x10sessionEndHeight\x12T\n" +
	"\x18endpoint_query_timestamp\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\x16endpointQueryTimestamp\x12_\n" +
	"\x1bendpoint_response_timestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampH\x00R\x19endpointResponseTimestamp\x88\x01\x01\x12K\n" +
	"\n" +
	"error_type\x18\n" +
	" \x01(\x0e2'.path.protocol.ShannonEndpointErrorTypeH\x01R\terrorType\x88\x01\x01\x12(\n" +
	"\rerror_details\x18\v \x01(\tH\x02R\ferrorDetails\x88\x01\x01\x12Z\n" +
	"\x14recommended_sanction\x18\f \x01(\x0e2\".path.protocol.ShannonSanctionTypeH\x03R\x13recommendedSanction\x88\x01\x01\x12V\n" +
	"\x11relay_miner_error\x18\r \x01(\v2%.path.protocol.ShannonRelayMinerErrorH\x04R\x0frelayMinerError\x88\x01\x01\x12m\n" +
	"2endpoint_backend_service_http_response_status_code\x18\x0e \x01(\x05H\x05R,endpointBackendServiceHttpResponseStatusCode\x88\x01\x01\x12o\n" +
	"3endpoint_backend_service_http_response_payload_size\x18\x0f \x01(\x03H\x06R-endpointBackendServiceHttpResponsePayloadSize\x88\x01\x01\x120\n" +
	"\x14is_fallback_endpoint\x18\x10 \x01(\bR\x12isFallbackEndpointB\x1e\n" +
	"\x1c_endpoint_response_timestampB\r\n" +
	"\v_error_typeB\x10\n" +
	"\x0e_error_detailsB\x17\n" +
	"\x15_recommended_sanctionB\x14\n" +
	"\x12_relay_miner_errorB5\n" +
	"3_endpoint_backend_service_http_response_status_codeB6\n" +
	"4_endpoint_backend_service_http_response_payload_size\"h\n" +
	"\x17ShannonObservationsList\x12M\n" +
	"\fobservations\x18\x01 \x03(\v2).path.protocol.ShannonRequestObservationsR\fobservations*\x9e\x05\n" +
	"\x17ShannonRequestErrorType\x12%\n" +
	"!SHANNON_REQUEST_ERROR_UNSPECIFIED\x10\x00\x12\"\n" +
	"\x1eSHANNON_REQUEST_ERROR_INTERNAL\x10\x01\x129\n" +
	"5SHANNON_REQUEST_ERROR_INTERNAL_NO_ENDPOINTS_AVAILABLE\x10\x02\x12A\n" +
	"=SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_APP_FETCH_ERR\x10\x03\x12B\n" +
	">SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_APP_DELEGATION\x10\x04\x12?\n" +
	";SHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_NO_SESSIONS\x10\x05\x12G\n" +
	"CSHANNON_REQUEST_ERROR_INTERNAL_CENTRALIZED_MODE_NO_APPS_FOR_SERVICE\x10\x06\x129\n" +
	"5SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_GET_APP_HTTP\x10\a\x126\n" +
	"2SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_FETCH_APP\x10\b\x12B\n" +
	">SHANNON_REQUEST_ERROR_INTERNAL_DELEGATED_APP_DOES_NOT_DELEGATE\x10\t\x125\n" +
	"1SHANNON_REQUEST_ERROR_INTERNAL_SIGNER_SETUP_ERROR\x10\n" +
	"*\xd6\x11\n" +
	"\x18ShannonEndpointErrorType\x12&\n" +
	"\"SHANNON_ENDPOINT_ERROR_UNSPECIFIED\x10\x00\x12'\n" +
	"\x1fSHANNON_ENDPOINT_ERROR_INTERNAL\x10\x01\x1a\x02\b\x01\x12!\n" +
	"\x1dSHANNON_ENDPOINT_ERROR_CONFIG\x10\x02\x12\"\n" +
	"\x1eSHANNON_ENDPOINT_ERROR_TIMEOUT\x10\x03\x120\n" +
	",SHANNON_ENDPOINT_ERROR_PAYLOAD_UNMARSHAL_ERR\x10\x04\x122\n" +
	".SHANNON_ENDPOINT_ERROR_RESPONSE_VALIDATION_ERR\x10\x05\x122\n" +
	".SHANNON_ENDPOINT_ERROR_RESPONSE_GET_PUBKEY_ERR\x10\x06\x12.\n" +
	"*SHANNON_ENDPOINT_ERROR_NIL_SUPPLIER_PUBKEY\x10\a\x12<\n" +
	"8SHANNON_ENDPOINT_ERROR_RESPONSE_SIGNATURE_VALIDATION_ERR\x10\b\x122\n" +
	".SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_REFUSED\x10\n" +
	"\x120\n" +
	",SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_RESET\x10\v\x122\n" +
	".SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_TIMEOUT\x10\f\x120\n" +
	",SHANNON_ENDPOINT_ERROR_HTTP_NO_ROUTE_TO_HOST\x10\r\x123\n" +
	"/SHANNON_ENDPOINT_ERROR_HTTP_NETWORK_UNREACHABLE\x10\x0e\x12+\n" +
	"'SHANNON_ENDPOINT_ERROR_HTTP_BROKEN_PIPE\x10\x0f\x12*\n" +
	"&SHANNON_ENDPOINT_ERROR_HTTP_IO_TIMEOUT\x10\x10\x12/\n" +
	"+SHANNON_ENDPOINT_ERROR_HTTP_TRANSPORT_ERROR\x10\x11\x12,\n" +
	"(SHANNON_ENDPOINT_ERROR_HTTP_BAD_RESPONSE\x10\x12\x12.\n" +
	"*SHANNON_ENDPOINT_ERROR_HTTP_INVALID_STATUS\x10\x13\x129\n" +
	"5SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_CONNECTION_REFUSED\x10\x14\x12=\n" +
	"9SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SERVICE_NOT_CONFIGURED\x10\x15\x125\n" +
	"1SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_UNEXPECTED_EOF\x10\x16\x129\n" +
	"5SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_PROTOCOL_WIRE_TYPE\x10\x17\x12=\n" +
	"9SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_PROTOCOL_RELAY_REQUEST\x10\x18\x12>\n" +
	":SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SUPPLIERS_NOT_REACHABLE\x10\x19\x126\n" +
	"2SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_BACKEND_SERVICE\x10\x1a\x125\n" +
	"1SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_TCP_CONNECTION\x10\x1b\x12=\n" +
	"9SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RESPONSE_SIZE_EXCEEDED\x10\x1c\x12?\n" +
	";SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_SERVER_CLOSED_CONNECTION\x10\x1d\x125\n" +
	"1SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_HTTP_TRANSPORT\x10\x1e\x125\n" +
	"1SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_DNS_RESOLUTION\x10\x1f\x124\n" +
	"0SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_TLS_HANDSHAKE\x10 \x12-\n" +
	")SHANNON_ENDPOINT_REQUEST_CANCELED_BY_PATH\x10!\x12'\n" +
	"#SHANNON_ENDPOINT_ERROR_HTTP_UNKNOWN\x10\"\x12.\n" +
	"*SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_UNKNOWN\x10#\x12\"\n" +
	"\x1eSHANNON_ENDPOINT_ERROR_UNKNOWN\x10$\x12.\n" +
	"*SHANNON_ENDPOINT_ERROR_HTTP_NON_2XX_STATUS\x10%\x129\n" +
	"5SHANNON_ENDPOINT_ERROR_HTTP_CONTEXT_DEADLINE_EXCEEDED\x10&\x126\n" +
	"2SHANNON_ENDPOINT_ERROR_WEBSOCKET_CONNECTION_FAILED\x10'\x12;\n" +
	"7SHANNON_ENDPOINT_ERROR_WEBSOCKET_REQUEST_SIGNING_FAILED\x10(\x12E\n" +
	"ASHANNON_ENDPOINT_ERROR_WEBSOCKET_RELAY_RESPONSE_VALIDATION_FAILED\x10)\x12/\n" +
	"+SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_4XX\x10*\x12/\n" +
	"+SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_5XX\x10+*\x9b\x01\n" +
	"\x13ShannonSanctionType\x12 \n" +
	"\x1cSHANNON_SANCTION_UNSPECIFIED\x10\x00\x12\x1c\n" +
	"\x18SHANNON_SANCTION_SESSION\x10\x01\x12\x1e\n" +
	"\x1aSHANNON_SANCTION_PERMANENT\x10\x02\x12$\n" +
	" SHANNON_SANCTION_DO_NOT_SANCTION\x10\x03B5Z3github.com/buildwithgrove/path/observation/protocolb\x06proto3"

var (
	file_path_protocol_shannon_proto_rawDescOnce sync.Once
	file_path_protocol_shannon_proto_rawDescData []byte
)

func file_path_protocol_shannon_proto_rawDescGZIP() []byte {
	file_path_protocol_shannon_proto_rawDescOnce.Do(func() {
		file_path_protocol_shannon_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_path_protocol_shannon_proto_rawDesc), len(file_path_protocol_shannon_proto_rawDesc)))
	})
	return file_path_protocol_shannon_proto_rawDescData
}

var file_path_protocol_shannon_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_path_protocol_shannon_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
var file_path_protocol_shannon_proto_goTypes = []any{
	(ShannonRequestErrorType)(0),                                   // 0: path.protocol.ShannonRequestErrorType
	(ShannonEndpointErrorType)(0),                                  // 1: path.protocol.ShannonEndpointErrorType
	(ShannonSanctionType)(0),                                       // 2: path.protocol.ShannonSanctionType
	(ShannonWebsocketConnectionObservation_ConnectionEventType)(0), // 3: path.protocol.ShannonWebsocketConnectionObservation.ConnectionEventType
	(*ShannonRequestError)(nil),                                    // 4: path.protocol.ShannonRequestError
	(*ShannonRelayMinerError)(nil),                                 // 5: path.protocol.ShannonRelayMinerError
	(*ShannonWebsocketConnectionObservation)(nil),                  // 6: path.protocol.ShannonWebsocketConnectionObservation
	(*ShannonWebsocketMessageObservation)(nil),                     // 7: path.protocol.ShannonWebsocketMessageObservation
	(*ShannonRequestObservations)(nil),                             // 8: path.protocol.ShannonRequestObservations
	(*ShannonHTTPEndpointObservations)(nil),                        // 9: path.protocol.ShannonHTTPEndpointObservations
	(*ShannonEndpointObservation)(nil),                             // 10: path.protocol.ShannonEndpointObservation
	(*ShannonObservationsList)(nil),                                // 11: path.protocol.ShannonObservationsList
	(*timestamppb.Timestamp)(nil),                                  // 12: google.protobuf.Timestamp
}
var file_path_protocol_shannon_proto_depIdxs = []int32{
	0,  // 0: path.protocol.ShannonRequestError.error_type:type_name -> path.protocol.ShannonRequestErrorType
	1,  // 1: path.protocol.ShannonWebsocketConnectionObservation.error_type:type_name -> path.protocol.ShannonEndpointErrorType
	2,  // 2: path.protocol.ShannonWebsocketConnectionObservation.recommended_sanction:type_name -> path.protocol.ShannonSanctionType
	12, // 3: path.protocol.ShannonWebsocketConnectionObservation.connection_established_timestamp:type_name -> google.protobuf.Timestamp
	12, // 4: path.protocol.ShannonWebsocketConnectionObservation.connection_closed_timestamp:type_name -> google.protobuf.Timestamp
	3,  // 5: path.protocol.ShannonWebsocketConnectionObservation.event_type:type_name -> path.protocol.ShannonWebsocketConnectionObservation.ConnectionEventType
	12, // 6: path.protocol.ShannonWebsocketMessageObservation.message_timestamp:type_name -> google.protobuf.Timestamp
	1,  // 7: path.protocol.ShannonWebsocketMessageObservation.error_type:type_name -> path.protocol.ShannonEndpointErrorType
	2,  // 8: path.protocol.ShannonWebsocketMessageObservation.recommended_sanction:type_name -> path.protocol.ShannonSanctionType
	5,  // 9: path.protocol.ShannonWebsocketMessageObservation.relay_miner_error:type_name -> path.protocol.ShannonRelayMinerError
	4,  // 10: path.protocol.ShannonRequestObservations.request_error:type_name -> path.protocol.ShannonRequestError
	9,  // 11: path.protocol.ShannonRequestObservations.http_observations:type_name -> path.protocol.ShannonHTTPEndpointObservations
	6,  // 12: path.protocol.ShannonRequestObservations.websocket_connection_observation:type_name -> path.protocol.ShannonWebsocketConnectionObservation
	7,  // 13: path.protocol.ShannonRequestObservations.websocket_message_observation:type_name -> path.protocol.ShannonWebsocketMessageObservation
	10, // 14: path.protocol.ShannonHTTPEndpointObservations.endpoint_observations:type_name -> path.protocol.ShannonEndpointObservation
	12, // 15: path.protocol.ShannonEndpointObservation.endpoint_query_timestamp:type_name -> google.protobuf.Timestamp
	12, // 16: path.protocol.ShannonEndpointObservation.endpoint_response_timestamp:type_name -> google.protobuf.Timestamp
	1,  // 17: path.protocol.ShannonEndpointObservation.error_type:type_name -> path.protocol.ShannonEndpointErrorType
	2,  // 18: path.protocol.ShannonEndpointObservation.recommended_sanction:type_name -> path.protocol.ShannonSanctionType
	5,  // 19: path.protocol.ShannonEndpointObservation.relay_miner_error:type_name -> path.protocol.ShannonRelayMinerError
	8,  // 20: path.protocol.ShannonObservationsList.observations:type_name -> path.protocol.ShannonRequestObservations
	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_path_protocol_shannon_proto_init() }
func file_path_protocol_shannon_proto_init() {
	if File_path_protocol_shannon_proto != nil {
		return
	}
	file_path_protocol_shannon_proto_msgTypes[2].OneofWrappers = []any{}
	file_path_protocol_shannon_proto_msgTypes[3].OneofWrappers = []any{}
	file_path_protocol_shannon_proto_msgTypes[4].OneofWrappers = []any{
		(*ShannonRequestObservations_HttpObservations)(nil),
		(*ShannonRequestObservations_WebsocketConnectionObservation)(nil),
		(*ShannonRequestObservations_WebsocketMessageObservation)(nil),
	}
	file_path_protocol_shannon_proto_msgTypes[6].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_path_protocol_shannon_proto_rawDesc), len(file_path_protocol_shannon_proto_rawDesc)),
			NumEnums:      4,
			NumMessages:   8,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_path_protocol_shannon_proto_goTypes,
		DependencyIndexes: file_path_protocol_shannon_proto_depIdxs,
		EnumInfos:         file_path_protocol_shannon_proto_enumTypes,
		MessageInfos:      file_path_protocol_shannon_proto_msgTypes,
	}.Build()
	File_path_protocol_shannon_proto = out.File
	file_path_protocol_shannon_proto_goTypes = nil
	file_path_protocol_shannon_proto_depIdxs = nil
}
