celerityv1

type Ack struct {
	Success      bool   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	// contains filtered or unexported fields
}

type BatchResult struct {
	Success  bool             `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Failures []*RecordFailure `protobuf:"bytes,2,rep,name=failures,proto3" json:"failures,omitempty"`
	// contains filtered or unexported fields
}

type Cancel struct {
	Id     string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Reason Cancel_Reason `protobuf:"varint,2,opt,name=reason,proto3,enum=celerity.runtime.v1.Cancel_Reason" json:"reason,omitempty"`
	// contains filtered or unexported fields
}

type Cancel_Reason int32

type ConsumerBatch struct {
	Records    []*ConsumerRecord `protobuf:"bytes,1,rep,name=records,proto3" json:"records,omitempty"`
	SourceId   string            `protobuf:"bytes,2,opt,name=source_id,json=sourceId,proto3" json:"source_id,omitempty"`
	SourceType string            `protobuf:"bytes,3,opt,name=source_type,json=sourceType,proto3" json:"source_type,omitempty"`
	// Provider-specific, opaque.
	Vendor []byte `protobuf:"bytes,4,opt,name=vendor,proto3" json:"vendor,omitempty"`
	// contains filtered or unexported fields
}

type ConsumerRecord struct {
	MessageId  string `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	Body       []byte `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
	Source     string `protobuf:"bytes,3,opt,name=source,proto3" json:"source,omitempty"`
	EventType  string `protobuf:"bytes,4,opt,name=event_type,json=eventType,proto3" json:"event_type,omitempty"`
	Attributes []byte `protobuf:"bytes,5,opt,name=attributes,proto3" json:"attributes,omitempty"`
	Vendor     []byte `protobuf:"bytes,6,opt,name=vendor,proto3" json:"vendor,omitempty"`
	// contains filtered or unexported fields
}

type CreditGrant struct {
	Additional uint32 `protobuf:"varint,1,opt,name=additional,proto3" json:"additional,omitempty"`
	// contains filtered or unexported fields
}

type CustomInvoke struct {
	HandlerName string `protobuf:"bytes,1,opt,name=handler_name,json=handlerName,proto3" json:"handler_name,omitempty"`
	Input       []byte `protobuf:"bytes,2,opt,name=input,proto3" json:"input,omitempty"`
	// contains filtered or unexported fields
}

type CustomInvokeResult struct {

	// Opaque, and carried to whoever asked for the invocation exactly as sent.
	// Whether it has to be text is that caller's constraint rather than this
	// contract's. The runtime's local invoke endpoint answers in JSON, so it
	// refuses output that is not valid UTF-8 rather than altering it.
	Output       []byte `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"`
	ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	// contains filtered or unexported fields
}

type Dispatch struct {
	Id          string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	HandlerTag  string `protobuf:"bytes,2,opt,name=handler_tag,json=handlerTag,proto3" json:"handler_tag,omitempty"`
	TimestampMs uint64 `protobuf:"varint,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
	// When the runtime stops waiting for this event. The handler should treat it
	// as its own deadline; the runtime enforces it independently.
	DeadlineUnixMs int64 `protobuf:"varint,4,opt,name=deadline_unix_ms,json=deadlineUnixMs,proto3" json:"deadline_unix_ms,omitempty"`
	// The trace context of whatever produced the event, so a handler's spans
	// continue the trace rather than starting one of their own. Carries the W3C
	// trace context keys, `traceparent` and, where an upstream sent one,
	// `tracestate`, alongside platform specific ids such as `xray_trace_id`.
	//
	// Empty where the runtime has no trace to propagate, which is the case when
	// tracing is disabled.
	TraceContext map[string]string `` /* 171-byte string literal not displayed */
	// Types that are valid to be assigned to Source:
	//
	//	*Dispatch_Http
	//	*Dispatch_Websocket
	//	*Dispatch_Consumer
	//	*Dispatch_Schedule
	//	*Dispatch_Custom
	Source isDispatch_Source `protobuf_oneof:"source"`
	// contains filtered or unexported fields
}

type Dispatch_Consumer struct {
	Consumer *ConsumerBatch `protobuf:"bytes,12,opt,name=consumer,proto3,oneof"`
}

type Dispatch_Custom struct {
	Custom *CustomInvoke `protobuf:"bytes,14,opt,name=custom,proto3,oneof"`
}

type Dispatch_Http struct {
	Http *HttpRequest `protobuf:"bytes,10,opt,name=http,proto3,oneof"`
}

type Dispatch_Schedule struct {
	Schedule *ScheduleTrigger `protobuf:"bytes,13,opt,name=schedule,proto3,oneof"`
}

type Dispatch_Websocket struct {
	Websocket *WebSocketMessage `protobuf:"bytes,11,opt,name=websocket,proto3,oneof"`
}

type Drain struct {
	DeadlineUnixMs int64 `protobuf:"varint,1,opt,name=deadline_unix_ms,json=deadlineUnixMs,proto3" json:"deadline_unix_ms,omitempty"`
	// contains filtered or unexported fields
}

type Draining struct {
	DeadlineUnixMs int64 `protobuf:"varint,1,opt,name=deadline_unix_ms,json=deadlineUnixMs,proto3" json:"deadline_unix_ms,omitempty"`
	// contains filtered or unexported fields
}

type HandlerConfig struct {

	// The blueprint resource this handler is declared as, which is what its
	// handler tag is built from.
	HandlerName    string `protobuf:"bytes,1,opt,name=handler_name,json=handlerName,proto3" json:"handler_name,omitempty"`
	HandlerTag     string `protobuf:"bytes,2,opt,name=handler_tag,json=handlerTag,proto3" json:"handler_tag,omitempty"`
	TimeoutMs      int64  `protobuf:"varint,3,opt,name=timeout_ms,json=timeoutMs,proto3" json:"timeout_ms,omitempty"`
	TracingEnabled bool   `protobuf:"varint,4,opt,name=tracing_enabled,json=tracingEnabled,proto3" json:"tracing_enabled,omitempty"`
	// The name the blueprint publishes this handler under, from spec.handlerName.
	// Empty when the blueprint does not set one. A deployment addresses a handler
	// by this name, and the runtime's local invoke endpoint accepts it alongside
	// the resource name.
	PublishedName string `protobuf:"bytes,5,opt,name=published_name,json=publishedName,proto3" json:"published_name,omitempty"`
	// contains filtered or unexported fields
}

type HandlerError struct {
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	Type    string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	Stack   string `protobuf:"bytes,3,opt,name=stack,proto3" json:"stack,omitempty"`
	// contains filtered or unexported fields
}

type HandlerLimit struct {
	HandlerTag    string `protobuf:"bytes,1,opt,name=handler_tag,json=handlerTag,proto3" json:"handler_tag,omitempty"`
	MaxConcurrent uint32 `protobuf:"varint,2,opt,name=max_concurrent,json=maxConcurrent,proto3" json:"max_concurrent,omitempty"`
	// contains filtered or unexported fields
}

type HandlerMessage struct {

	// Types that are valid to be assigned to Frame:
	//
	//	*HandlerMessage_Ready
	//	*HandlerMessage_Result
	//	*HandlerMessage_Credit
	//	*HandlerMessage_WsSend
	//	*HandlerMessage_Draining
	Frame isHandlerMessage_Frame `protobuf_oneof:"frame"`
	// contains filtered or unexported fields
}

type HandlerMessage_Credit struct {
	Credit *CreditGrant `protobuf:"bytes,3,opt,name=credit,proto3,oneof"`
}

type HandlerMessage_Draining struct {
	Draining *Draining `protobuf:"bytes,5,opt,name=draining,proto3,oneof"`
}

type HandlerMessage_Ready struct {
	Ready *Ready `protobuf:"bytes,1,opt,name=ready,proto3,oneof"`
}

type HandlerMessage_Result struct {
	Result *Result `protobuf:"bytes,2,opt,name=result,proto3,oneof"`
}

type HandlerMessage_WsSend struct {
	WsSend *WsSend `protobuf:"bytes,4,opt,name=ws_send,json=wsSend,proto3,oneof"`
}

type HandlerRuntimeServiceClient interface {
	EventStream(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[HandlerMessage, RuntimeMessage], error)
}

type HandlerRuntimeServiceServer interface {
	EventStream(grpc.BidiStreamingServer[HandlerMessage, RuntimeMessage]) error
	// contains filtered or unexported methods
}

type HandlerRuntimeService_EventStreamClient = grpc.BidiStreamingClient[HandlerMessage, RuntimeMessage]

type HandlerRuntimeService_EventStreamServer = grpc.BidiStreamingServer[HandlerMessage, RuntimeMessage]

type HttpRequest struct {

	// Uppercase and canonical.
	Method string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
	// Raw, percent-encoded as received.
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// The route template this request matched, in the router's own form, so a
	// blueprint's /files/{path+} arrives as /files/{*path}. The same form the
	// handler tag is built from.
	Route string `protobuf:"bytes,3,opt,name=route,proto3" json:"route,omitempty"`
	// A catch-all parameter yields one value per path segment. Segments are split
	// from the raw path before being percent-decoded, so a segment containing an
	// encoded separator survives intact.
	PathParams  map[string]*Values `` /* 165-byte string literal not displayed */
	QueryParams map[string]*Values `` /* 168-byte string literal not displayed */
	// Names are lowercase.
	Headers   map[string]*Values `` /* 141-byte string literal not displayed */
	SourceIp  string             `protobuf:"bytes,7,opt,name=source_ip,json=sourceIp,proto3" json:"source_ip,omitempty"`
	RequestId string             `protobuf:"bytes,8,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Opaque. The runtime never parses this; the media type comes from the
	// content-type header.
	Body []byte `protobuf:"bytes,9,opt,name=body,proto3" json:"body,omitempty"`
	// contains filtered or unexported fields
}

type HttpResponse struct {

	// 100 to 999. The smallest integer protobuf offers is wider than a status can
	// be, so a value outside that range is a fault in the handler and the runtime
	// answers 500 rather than narrowing it, which would let 65736 arrive as 200.
	Status uint32 `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	// Multi-valued, so a handler can emit two Set-Cookie headers, which RFC 9110
	// forbids folding into one comma-separated value.
	Headers map[string]*Values `` /* 141-byte string literal not displayed */
	Body    []byte             `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
	// contains filtered or unexported fields
}

type ProtocolVersion struct {
	Major uint32 `protobuf:"varint,1,opt,name=major,proto3" json:"major,omitempty"`
	Minor uint32 `protobuf:"varint,2,opt,name=minor,proto3" json:"minor,omitempty"`
	// contains filtered or unexported fields
}

type Ready struct {

	// The handler tags this process actually serves.
	HandlerTags []string `protobuf:"bytes,1,rep,name=handler_tags,json=handlerTags,proto3" json:"handler_tags,omitempty"`
	// Total events the runtime may have in flight to this process, across all
	// tags. SDKs should set this to their worker pool size: throughput saturates
	// there, and every unit beyond it adds latency for almost no throughput.
	InitialCredit uint32 `protobuf:"varint,2,opt,name=initial_credit,json=initialCredit,proto3" json:"initial_credit,omitempty"`
	SdkVersion    string `protobuf:"bytes,3,opt,name=sdk_version,json=sdkVersion,proto3" json:"sdk_version,omitempty"`
	// Optional per-tag concurrency caps, so one slow tag cannot consume the whole
	// credit window and starve the others.
	Limits []*HandlerLimit `protobuf:"bytes,4,rep,name=limits,proto3" json:"limits,omitempty"`
	// The protocol version this handler was built against. Required. A handler
	// that declares none was built against a version this contract cannot
	// determine, and is refused rather than assumed to speak the current one.
	ProtocolVersion *ProtocolVersion `protobuf:"bytes,5,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	// contains filtered or unexported fields
}

type ReadyAck struct {
	Accepted bool `protobuf:"varint,1,opt,name=accepted,proto3" json:"accepted,omitempty"`
	// Registered by the handler but absent from the blueprint.
	UnknownTags []string `protobuf:"bytes,2,rep,name=unknown_tags,json=unknownTags,proto3" json:"unknown_tags,omitempty"`
	// Present in the blueprint but not registered by the handler.
	UnhandledTags []string `protobuf:"bytes,3,rep,name=unhandled_tags,json=unhandledTags,proto3" json:"unhandled_tags,omitempty"`
	// Unspecified where the handler was accepted, since the tag lists alone
	// cannot tell a version refusal from an accepted handler with nothing to
	// report.
	RefusedReason ReadyAck_RefusedReason `` /* 149-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ReadyAck_RefusedReason int32

type RecordFailure struct {

	// As it arrived on the ConsumerRecord. A name that matches no record in the
	// batch leaves nothing behind, so a handler that rewrites or generates ids
	// has to answer with the ones it was given.
	MessageId    string `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	// contains filtered or unexported fields
}

type Result struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Credit returned along with this result. Zero withholds, telling the runtime
	// to stop dispatching to this stream until a later CreditGrant. SDKs should
	// default to 1 and must send this even when the handler panics, since a
	// missed grant drains the window and stalls the stream silently.
	//
	// When the runtime has already taken the place back, having cancelled the
	// event and waited out the grace period, a grant here is ignored, since
	// returning the same place twice would grow the window. Zero still withholds,
	// and the runtime gives up the place it returned.
	CreditGrant uint32 `protobuf:"varint,2,opt,name=credit_grant,json=creditGrant,proto3" json:"credit_grant,omitempty"`
	// Types that are valid to be assigned to Outcome:
	//
	//	*Result_Http
	//	*Result_Websocket
	//	*Result_Consumer
	//	*Result_Schedule
	//	*Result_Custom
	//	*Result_Error
	Outcome isResult_Outcome `protobuf_oneof:"outcome"`
	// contains filtered or unexported fields
}

type Result_Consumer struct {
	Consumer *BatchResult `protobuf:"bytes,12,opt,name=consumer,proto3,oneof"`
}

type Result_Custom struct {
	Custom *CustomInvokeResult `protobuf:"bytes,14,opt,name=custom,proto3,oneof"`
}

type Result_Error struct {
	// An unhandled error in user code.
	Error *HandlerError `protobuf:"bytes,15,opt,name=error,proto3,oneof"`
}

type Result_Http struct {
	Http *HttpResponse `protobuf:"bytes,10,opt,name=http,proto3,oneof"`
}

type Result_Schedule struct {
	Schedule *Ack `protobuf:"bytes,13,opt,name=schedule,proto3,oneof"`
}

type Result_Websocket struct {
	Websocket *Ack `protobuf:"bytes,11,opt,name=websocket,proto3,oneof"`
}

type RuntimeConfig struct {
	TracingEnabled bool             `protobuf:"varint,1,opt,name=tracing_enabled,json=tracingEnabled,proto3" json:"tracing_enabled,omitempty"`
	MetricsEnabled bool             `protobuf:"varint,2,opt,name=metrics_enabled,json=metricsEnabled,proto3" json:"metrics_enabled,omitempty"`
	Handlers       []*HandlerConfig `protobuf:"bytes,3,rep,name=handlers,proto3" json:"handlers,omitempty"`
	// The protocol version this runtime serves, sent before the handler is asked
	// for anything so that it can refuse for itself rather than waiting to be
	// refused.
	ProtocolVersion *ProtocolVersion `protobuf:"bytes,4,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	// contains filtered or unexported fields
}

type RuntimeMessage struct {

	// Types that are valid to be assigned to Frame:
	//
	//	*RuntimeMessage_Config
	//	*RuntimeMessage_ReadyAck
	//	*RuntimeMessage_Dispatch
	//	*RuntimeMessage_Cancel
	//	*RuntimeMessage_Drain
	//	*RuntimeMessage_WsAck
	Frame isRuntimeMessage_Frame `protobuf_oneof:"frame"`
	// contains filtered or unexported fields
}

type RuntimeMessage_Cancel struct {
	Cancel *Cancel `protobuf:"bytes,4,opt,name=cancel,proto3,oneof"`
}

type RuntimeMessage_Config struct {
	// Sent first, before the handler's Ready, so an SDK can check the handlers
	// registered in code against the ones the blueprint declares.
	Config *RuntimeConfig `protobuf:"bytes,1,opt,name=config,proto3,oneof"`
}

type RuntimeMessage_Dispatch struct {
	Dispatch *Dispatch `protobuf:"bytes,3,opt,name=dispatch,proto3,oneof"`
}

type RuntimeMessage_Drain struct {
	Drain *Drain `protobuf:"bytes,5,opt,name=drain,proto3,oneof"`
}

type RuntimeMessage_ReadyAck struct {
	ReadyAck *ReadyAck `protobuf:"bytes,2,opt,name=ready_ack,json=readyAck,proto3,oneof"`
}

type RuntimeMessage_WsAck struct {
	WsAck *WsSendAck `protobuf:"bytes,6,opt,name=ws_ack,json=wsAck,proto3,oneof"`
}

type ScheduleTrigger struct {
	ScheduleId string `protobuf:"bytes,1,opt,name=schedule_id,json=scheduleId,proto3" json:"schedule_id,omitempty"`
	MessageId  string `protobuf:"bytes,2,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	Schedule   string `protobuf:"bytes,3,opt,name=schedule,proto3" json:"schedule,omitempty"`
	Input      []byte `protobuf:"bytes,4,opt,name=input,proto3" json:"input,omitempty"`
	Vendor     []byte `protobuf:"bytes,5,opt,name=vendor,proto3" json:"vendor,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedHandlerRuntimeServiceServer struct{}

type UnsafeHandlerRuntimeServiceServer interface {
	// contains filtered or unexported methods
}

type Values struct {
	Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

type WebSocketMessage struct {
	Route        string `protobuf:"bytes,1,opt,name=route,proto3" json:"route,omitempty"`
	ConnectionId string `protobuf:"bytes,2,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"`
	SourceIp     string `protobuf:"bytes,3,opt,name=source_ip,json=sourceIp,proto3" json:"source_ip,omitempty"`
	RequestId    string `protobuf:"bytes,4,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	Message      []byte `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
	// Whether this arrived as a binary frame rather than a text one. A byte body
	// alone cannot express the distinction, and the WebSocket protocol treats
	// the two frame types as distinct.
	IsBinary bool `protobuf:"varint,6,opt,name=is_binary,json=isBinary,proto3" json:"is_binary,omitempty"`
	// The id this message is known by, which is the one the client gave it when
	// it gave one and a runtime generated one otherwise.
	//
	// Distinct from request_id, which identifies the delivery. This identifies
	// the message, so it is what an acknowledgement names and what a lost
	// message notification refers to, and a handler needs it to tie its own
	// instrumentation to what the client sees.
	MessageId string `protobuf:"bytes,7,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	// contains filtered or unexported fields
}

type WsOutbound struct {
	ConnectionId string `protobuf:"bytes,1,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"`
	// Sent to the socket exactly as given.
	//
	// When is_binary is set this must be in the Celerity Binary Message Format,
	// `<routeLength><route><requireAck><messageIdLength><messageId><message>`. A
	// client reads every binary frame that is not a reserved one as a framed
	// message, so raw bytes are not read as a payload, they are read as a route
	// length, a route and an id, leaving the application a short payload under a
	// route nothing serves. A message carrying no id sets both requireAck and
	// messageIdLength to zero. The runtime refuses a binary message it cannot
	// read as a frame rather than sending one no client can use, reporting it as
	// a WsSendFailure for that message.
	//
	// Text messages are unconstrained beyond the protocol's reserved keys.
	Message             []byte   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	IsBinary            bool     `protobuf:"varint,3,opt,name=is_binary,json=isBinary,proto3" json:"is_binary,omitempty"`
	InformClientsOnLoss []string `protobuf:"bytes,4,rep,name=inform_clients_on_loss,json=informClientsOnLoss,proto3" json:"inform_clients_on_loss,omitempty"`
	// Identifies this message to the runtime, for the acknowledgement between
	// nodes when the target connection lives on another one, and in the loss
	// event delivered to the clients named in inform_clients_on_loss. Generated
	// by the runtime when left empty, which is the right choice unless the
	// handler needs to match a loss event back to what it sent.
	//
	// Not the message id the client sees. The runtime sends `message` to the
	// socket exactly as given, so a client-visible id, and the acknowledgement
	// and deduplication that depend on it, is something the handler puts in the
	// payload it composes.
	MessageId string `protobuf:"bytes,5,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	// The connection that caused this message to be sent, carried through to the
	// loss event so an informed client can tell who was being replied to. Only
	// meaningful alongside inform_clients_on_loss.
	Caller string `protobuf:"bytes,6,opt,name=caller,proto3" json:"caller,omitempty"`
	// Whether the WsSendAck for this message waits for the client to acknowledge
	// it, rather than reporting the write to the socket.
	//
	// The message has to ask the client for an acknowledgement in the payload it
	// carries, which the runtime does not compose. Setting this for one that
	// asks nothing leaves the send waiting for an answer that is never coming,
	// until the runtime declares the message lost.
	//
	// Waited for wherever the connection is, so a send means the same thing in a
	// single node deployment as in a cluster. Sending it again while attempts
	// remain, and declaring it lost when they run out, is the runtime's to do.
	WaitForAck bool `protobuf:"varint,7,opt,name=wait_for_ack,json=waitForAck,proto3" json:"wait_for_ack,omitempty"`
	// contains filtered or unexported fields
}

type WsSend struct {
	CorrelationId string        `protobuf:"bytes,1,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"`
	Messages      []*WsOutbound `protobuf:"bytes,2,rep,name=messages,proto3" json:"messages,omitempty"`
	// contains filtered or unexported fields
}

type WsSendAck struct {
	CorrelationId string `protobuf:"bytes,1,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"`
	// True when every message was delivered, equivalent to failures being empty.
	Success  bool             `protobuf:"varint,2,opt,name=success,proto3" json:"success,omitempty"`
	Failures []*WsSendFailure `protobuf:"bytes,3,rep,name=failures,proto3" json:"failures,omitempty"`
	// contains filtered or unexported fields
}

type WsSendFailure struct {

	// Index into WsSend.messages. Identifies the message rather than message_id
	// does, because the runtime generates that when the handler leaves it empty,
	// so the handler may never have seen it.
	Index        uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	ConnectionId string `protobuf:"bytes,2,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"`
	ErrorMessage string `protobuf:"bytes,3,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	// contains filtered or unexported fields
}