// Daemon multiplexer wire schema: the broker-to-daemon conversation that
// multiplexes independently cancellable logical streams over one pooled
// physical connection.
//
// daemonmux is a third conversation, separate from the session protocol
// (tags 1-32) and the broker protocol (client 101-111, server 201-209):
// client tags 301-305 and server tags 401-406 are disjoint from every other
// tag, and each direction is its own closed oneof union. The physical
// preamble is a separate adapter message pair, not an envelope variant:
// roles 5/6 negotiate the per-connection ceilings, the authenticated daemon
// identity, and the accepted policy once, before any application message.
//
// MuxData, MuxClose, MuxReset, and MuxWindowUpdate are shared payloads carried in both
// directions; MuxOpen carries the full stream identity, and every later
// frame is routed by physical_stream_id alone.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.12
// 	protoc        (unknown)
// source: multiplex.proto

package wire

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

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

// MuxStreamRef identifies one logical stream multiplexed over one physical
// daemon connection: the mux-local physical_stream_id asserted by the
// opening side, the broker epoch and client connection that own the stream,
// and the broker client_stream_id it carries. physical_stream_id never
// crosses a physical connection; client_stream_id never crosses a broker
// connection or epoch. Every numeric value is nonzero and connection_id is
// exactly 16 bytes.
type MuxStreamRef struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	PhysicalStreamId uint64                 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
	BrokerEpoch      uint64                 `protobuf:"varint,2,opt,name=broker_epoch,json=brokerEpoch,proto3" json:"broker_epoch,omitempty"`
	ConnectionId     []byte                 `protobuf:"bytes,3,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"` // exactly 16 bytes
	ClientStreamId   uint64                 `protobuf:"varint,4,opt,name=client_stream_id,json=clientStreamId,proto3" json:"client_stream_id,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*MuxStreamRef) ProtoMessage() {}

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

func (x *MuxStreamRef) GetPhysicalStreamId() uint64 {
	if x != nil {
		return x.PhysicalStreamId
	}
	return 0
}

func (x *MuxStreamRef) GetBrokerEpoch() uint64 {
	if x != nil {
		return x.BrokerEpoch
	}
	return 0
}

func (x *MuxStreamRef) GetConnectionId() []byte {
	if x != nil {
		return x.ConnectionId
	}
	return nil
}

func (x *MuxStreamRef) GetClientStreamId() uint64 {
	if x != nil {
		return x.ClientStreamId
	}
	return 0
}

// MuxOpen asks the daemon to open one independently cancellable logical
// stream over the physical connection. env is the per-request session
// environment and is never inherited from the broker process environment.
// The daemon revalidates the exact session identity before attachment.
// start_mode carries the broker's explicit daemon-start authorization so a
// transport can never widen it into a spawn.
type MuxOpen struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Ref   *MuxStreamRef          `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	// Closed taxonomy: 1 = attachment, 2 = control, 3 = observation.
	Purpose      uint32              `protobuf:"varint,2,opt,name=purpose,proto3" json:"purpose,omitempty"`
	Local        bool                `protobuf:"varint,3,opt,name=local,proto3" json:"local,omitempty"`
	Endpoint     string              `protobuf:"bytes,4,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	Registration *RemoteRegistration `protobuf:"bytes,5,opt,name=registration,proto3" json:"registration,omitempty"`
	Target       *ExactTarget        `protobuf:"bytes,6,opt,name=target,proto3" json:"target,omitempty"`
	Env          []string            `protobuf:"bytes,7,rep,name=env,proto3" json:"env,omitempty"`
	Policy       *BrokerWirePolicy   `protobuf:"bytes,8,opt,name=policy,proto3" json:"policy,omitempty"`
	// Closed attachment-admission taxonomy (ports.BrokerStreamAdmission):
	// 0 = none (control/observation), 1 = exact attach/resume carrying
	// target, 2 = create named carrying name, 3 = create ephemeral, 4 = attach
	// named carrying name.
	Admission uint32 `protobuf:"varint,9,opt,name=admission,proto3" json:"admission,omitempty"`
	Name      string `protobuf:"bytes,10,opt,name=name,proto3" json:"name,omitempty"`
	// Closed daemon-start taxonomy (ports.BrokerDaemonStartMode): 1 =
	// existing_only, 2 = start_if_needed. Always present; zero is refused.
	StartMode     uint32 `protobuf:"varint,11,opt,name=start_mode,json=startMode,proto3" json:"start_mode,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MuxOpen) ProtoMessage() {}

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

func (x *MuxOpen) GetRef() *MuxStreamRef {
	if x != nil {
		return x.Ref
	}
	return nil
}

func (x *MuxOpen) GetPurpose() uint32 {
	if x != nil {
		return x.Purpose
	}
	return 0
}

func (x *MuxOpen) GetLocal() bool {
	if x != nil {
		return x.Local
	}
	return false
}

func (x *MuxOpen) GetEndpoint() string {
	if x != nil {
		return x.Endpoint
	}
	return ""
}

func (x *MuxOpen) GetRegistration() *RemoteRegistration {
	if x != nil {
		return x.Registration
	}
	return nil
}

func (x *MuxOpen) GetTarget() *ExactTarget {
	if x != nil {
		return x.Target
	}
	return nil
}

func (x *MuxOpen) GetEnv() []string {
	if x != nil {
		return x.Env
	}
	return nil
}

func (x *MuxOpen) GetPolicy() *BrokerWirePolicy {
	if x != nil {
		return x.Policy
	}
	return nil
}

func (x *MuxOpen) GetAdmission() uint32 {
	if x != nil {
		return x.Admission
	}
	return 0
}

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

func (x *MuxOpen) GetStartMode() uint32 {
	if x != nil {
		return x.StartMode
	}
	return 0
}

// MuxOpened confirms one logical stream is established.
type MuxOpened struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ref           *MuxStreamRef          `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MuxOpened) ProtoMessage() {}

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

func (x *MuxOpened) GetRef() *MuxStreamRef {
	if x != nil {
		return x.Ref
	}
	return nil
}

// MuxRefused refuses one logical stream open. The typed error is
// mandatory: a refusal without a reason could not be classified.
type MuxRefused struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ref           *MuxStreamRef          `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	Error         *BrokerErrorDetail     `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MuxRefused) ProtoMessage() {}

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

func (x *MuxRefused) GetRef() *MuxStreamRef {
	if x != nil {
		return x.Ref
	}
	return nil
}

func (x *MuxRefused) GetError() *BrokerErrorDetail {
	if x != nil {
		return x.Error
	}
	return nil
}

// MuxData carries one opaque stream frame in either direction. Once a
// stream is opened it is routed by physical_stream_id alone and never
// repeats its scope.
type MuxData struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	PhysicalStreamId uint64                 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
	Data             []byte                 `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*MuxData) ProtoMessage() {}

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

func (x *MuxData) GetPhysicalStreamId() uint64 {
	if x != nil {
		return x.PhysicalStreamId
	}
	return 0
}

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

// MuxClose ends one logical stream in either direction.
type MuxClose struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	PhysicalStreamId uint64                 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*MuxClose) ProtoMessage() {}

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

func (x *MuxClose) GetPhysicalStreamId() uint64 {
	if x != nil {
		return x.PhysicalStreamId
	}
	return 0
}

// MuxReset aborts one logical stream in either direction. An unset error is
// an abort without a typed reason; a set error carries the failure.
type MuxReset struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	PhysicalStreamId uint64                 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
	Error            *BrokerErrorDetail     `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*MuxReset) ProtoMessage() {}

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

func (x *MuxReset) GetPhysicalStreamId() uint64 {
	if x != nil {
		return x.PhysicalStreamId
	}
	return 0
}

func (x *MuxReset) GetError() *BrokerErrorDetail {
	if x != nil {
		return x.Error
	}
	return nil
}

// MuxWindowUpdate returns receive credit for one logical stream in either
// direction: the receiver consumed MuxData frames worth `credit_bytes` credit
// bytes, so the sender may spend that many more. One MuxData frame costs its
// payload length plus 64 credit bytes. Each stream starts with the same window
// on both sides, derived from the negotiated ceilings; a sender never has more
// credit in flight than its window, so a slow receiver slows the sender
// instead of overflowing its queue.
type MuxWindowUpdate struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	PhysicalStreamId uint64                 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
	CreditBytes      uint64                 `protobuf:"varint,2,opt,name=credit_bytes,json=creditBytes,proto3" json:"credit_bytes,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*MuxWindowUpdate) ProtoMessage() {}

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

func (x *MuxWindowUpdate) GetPhysicalStreamId() uint64 {
	if x != nil {
		return x.PhysicalStreamId
	}
	return 0
}

func (x *MuxWindowUpdate) GetCreditBytes() uint64 {
	if x != nil {
		return x.CreditBytes
	}
	return 0
}

// MuxClientEnvelope is the closed broker-to-daemon mux union. Exactly one
// variant must be set per envelope; empty, duplicate, and wrong-direction
// payloads are rejected before generated unmarshal.
type MuxClientEnvelope struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Payload:
	//
	//	*MuxClientEnvelope_Open
	//	*MuxClientEnvelope_Data
	//	*MuxClientEnvelope_Close
	//	*MuxClientEnvelope_Reset_
	//	*MuxClientEnvelope_WindowUpdate
	Payload       isMuxClientEnvelope_Payload `protobuf_oneof:"payload"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MuxClientEnvelope) ProtoMessage() {}

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

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

func (x *MuxClientEnvelope) GetPayload() isMuxClientEnvelope_Payload {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *MuxClientEnvelope) GetOpen() *MuxOpen {
	if x != nil {
		if x, ok := x.Payload.(*MuxClientEnvelope_Open); ok {
			return x.Open
		}
	}
	return nil
}

func (x *MuxClientEnvelope) GetData() *MuxData {
	if x != nil {
		if x, ok := x.Payload.(*MuxClientEnvelope_Data); ok {
			return x.Data
		}
	}
	return nil
}

func (x *MuxClientEnvelope) GetClose() *MuxClose {
	if x != nil {
		if x, ok := x.Payload.(*MuxClientEnvelope_Close); ok {
			return x.Close
		}
	}
	return nil
}

func (x *MuxClientEnvelope) GetReset_() *MuxReset {
	if x != nil {
		if x, ok := x.Payload.(*MuxClientEnvelope_Reset_); ok {
			return x.Reset_
		}
	}
	return nil
}

func (x *MuxClientEnvelope) GetWindowUpdate() *MuxWindowUpdate {
	if x != nil {
		if x, ok := x.Payload.(*MuxClientEnvelope_WindowUpdate); ok {
			return x.WindowUpdate
		}
	}
	return nil
}

type isMuxClientEnvelope_Payload interface {
	isMuxClientEnvelope_Payload()
}

type MuxClientEnvelope_Open struct {
	Open *MuxOpen `protobuf:"bytes,301,opt,name=open,proto3,oneof"`
}

type MuxClientEnvelope_Data struct {
	Data *MuxData `protobuf:"bytes,302,opt,name=data,proto3,oneof"`
}

type MuxClientEnvelope_Close struct {
	Close *MuxClose `protobuf:"bytes,303,opt,name=close,proto3,oneof"`
}

type MuxClientEnvelope_Reset_ struct {
	Reset_ *MuxReset `protobuf:"bytes,304,opt,name=reset,proto3,oneof"`
}

type MuxClientEnvelope_WindowUpdate struct {
	WindowUpdate *MuxWindowUpdate `protobuf:"bytes,305,opt,name=window_update,json=windowUpdate,proto3,oneof"`
}

func (*MuxClientEnvelope_Open) isMuxClientEnvelope_Payload() {}

func (*MuxClientEnvelope_Data) isMuxClientEnvelope_Payload() {}

func (*MuxClientEnvelope_Close) isMuxClientEnvelope_Payload() {}

func (*MuxClientEnvelope_Reset_) isMuxClientEnvelope_Payload() {}

func (*MuxClientEnvelope_WindowUpdate) isMuxClientEnvelope_Payload() {}

// MuxServerEnvelope is the closed daemon-to-broker mux union. Exactly one
// variant must be set per envelope.
type MuxServerEnvelope struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Payload:
	//
	//	*MuxServerEnvelope_Opened
	//	*MuxServerEnvelope_Refused
	//	*MuxServerEnvelope_Data
	//	*MuxServerEnvelope_Close
	//	*MuxServerEnvelope_Reset_
	//	*MuxServerEnvelope_WindowUpdate
	Payload       isMuxServerEnvelope_Payload `protobuf_oneof:"payload"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MuxServerEnvelope) ProtoMessage() {}

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

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

func (x *MuxServerEnvelope) GetPayload() isMuxServerEnvelope_Payload {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *MuxServerEnvelope) GetOpened() *MuxOpened {
	if x != nil {
		if x, ok := x.Payload.(*MuxServerEnvelope_Opened); ok {
			return x.Opened
		}
	}
	return nil
}

func (x *MuxServerEnvelope) GetRefused() *MuxRefused {
	if x != nil {
		if x, ok := x.Payload.(*MuxServerEnvelope_Refused); ok {
			return x.Refused
		}
	}
	return nil
}

func (x *MuxServerEnvelope) GetData() *MuxData {
	if x != nil {
		if x, ok := x.Payload.(*MuxServerEnvelope_Data); ok {
			return x.Data
		}
	}
	return nil
}

func (x *MuxServerEnvelope) GetClose() *MuxClose {
	if x != nil {
		if x, ok := x.Payload.(*MuxServerEnvelope_Close); ok {
			return x.Close
		}
	}
	return nil
}

func (x *MuxServerEnvelope) GetReset_() *MuxReset {
	if x != nil {
		if x, ok := x.Payload.(*MuxServerEnvelope_Reset_); ok {
			return x.Reset_
		}
	}
	return nil
}

func (x *MuxServerEnvelope) GetWindowUpdate() *MuxWindowUpdate {
	if x != nil {
		if x, ok := x.Payload.(*MuxServerEnvelope_WindowUpdate); ok {
			return x.WindowUpdate
		}
	}
	return nil
}

type isMuxServerEnvelope_Payload interface {
	isMuxServerEnvelope_Payload()
}

type MuxServerEnvelope_Opened struct {
	Opened *MuxOpened `protobuf:"bytes,401,opt,name=opened,proto3,oneof"`
}

type MuxServerEnvelope_Refused struct {
	Refused *MuxRefused `protobuf:"bytes,402,opt,name=refused,proto3,oneof"`
}

type MuxServerEnvelope_Data struct {
	Data *MuxData `protobuf:"bytes,403,opt,name=data,proto3,oneof"`
}

type MuxServerEnvelope_Close struct {
	Close *MuxClose `protobuf:"bytes,404,opt,name=close,proto3,oneof"`
}

type MuxServerEnvelope_Reset_ struct {
	Reset_ *MuxReset `protobuf:"bytes,405,opt,name=reset,proto3,oneof"`
}

type MuxServerEnvelope_WindowUpdate struct {
	WindowUpdate *MuxWindowUpdate `protobuf:"bytes,406,opt,name=window_update,json=windowUpdate,proto3,oneof"`
}

func (*MuxServerEnvelope_Opened) isMuxServerEnvelope_Payload() {}

func (*MuxServerEnvelope_Refused) isMuxServerEnvelope_Payload() {}

func (*MuxServerEnvelope_Data) isMuxServerEnvelope_Payload() {}

func (*MuxServerEnvelope_Close) isMuxServerEnvelope_Payload() {}

func (*MuxServerEnvelope_Reset_) isMuxServerEnvelope_Payload() {}

func (*MuxServerEnvelope_WindowUpdate) isMuxServerEnvelope_Payload() {}

// MuxPreambleRequest is the daemonmux client's first frame on one physical
// connection: the requested per-connection ceilings and the broker policy
// the client asks the daemon to accept. The shared field numbers mirror
// MuxPreambleResponse, exactly as the session preamble pair does. Each
// ceiling is advertised independently per direction: max_aggregate_bytes is
// the buffered-bytes budget the client will enforce in the direction it
// accepts, and never shared with the opposite direction.
type MuxPreambleRequest struct {
	state                   protoimpl.MessageState `protogen:"open.v1"`
	Magic                   uint32                 `protobuf:"varint,1,opt,name=magic,proto3" json:"magic,omitempty"`                                                                        // must equal the shared preamble magic
	Epoch                   uint32                 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`                                                                        // must equal the shared protocol epoch
	Version                 uint32                 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`                                                                    // exact session protocol version
	Role                    *PreambleRole          `protobuf:"bytes,4,opt,name=role,proto3" json:"role,omitempty"`                                                                           // must be 5 (daemonmux client)
	MaxReceiveEnvelopeBytes uint64                 `protobuf:"varint,5,opt,name=max_receive_envelope_bytes,json=maxReceiveEnvelopeBytes,proto3" json:"max_receive_envelope_bytes,omitempty"` // requested 1 MiB..16 MiB
	StreamChunkLimit        uint64                 `protobuf:"varint,6,opt,name=stream_chunk_limit,json=streamChunkLimit,proto3" json:"stream_chunk_limit,omitempty"`                        // requested 1..64 KiB
	MaxStreams              uint64                 `protobuf:"varint,7,opt,name=max_streams,json=maxStreams,proto3" json:"max_streams,omitempty"`                                            // requested 1..128
	MaxAggregateBytes       uint64                 `protobuf:"varint,8,opt,name=max_aggregate_bytes,json=maxAggregateBytes,proto3" json:"max_aggregate_bytes,omitempty"`                     // requested 1 max chunk + overhead..64 MiB, per direction
	CapabilityBits          uint32                 `protobuf:"varint,9,opt,name=capability_bits,json=capabilityBits,proto3" json:"capability_bits,omitempty"`                                // must be zero
	Policy                  *BrokerWirePolicy      `protobuf:"bytes,10,opt,name=policy,proto3" json:"policy,omitempty"`                                                                      // requested connection policy
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

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

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

func (*MuxPreambleRequest) ProtoMessage() {}

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

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

func (x *MuxPreambleRequest) GetMagic() uint32 {
	if x != nil {
		return x.Magic
	}
	return 0
}

func (x *MuxPreambleRequest) GetEpoch() uint32 {
	if x != nil {
		return x.Epoch
	}
	return 0
}

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

func (x *MuxPreambleRequest) GetRole() *PreambleRole {
	if x != nil {
		return x.Role
	}
	return nil
}

func (x *MuxPreambleRequest) GetMaxReceiveEnvelopeBytes() uint64 {
	if x != nil {
		return x.MaxReceiveEnvelopeBytes
	}
	return 0
}

func (x *MuxPreambleRequest) GetStreamChunkLimit() uint64 {
	if x != nil {
		return x.StreamChunkLimit
	}
	return 0
}

func (x *MuxPreambleRequest) GetMaxStreams() uint64 {
	if x != nil {
		return x.MaxStreams
	}
	return 0
}

func (x *MuxPreambleRequest) GetMaxAggregateBytes() uint64 {
	if x != nil {
		return x.MaxAggregateBytes
	}
	return 0
}

func (x *MuxPreambleRequest) GetCapabilityBits() uint32 {
	if x != nil {
		return x.CapabilityBits
	}
	return 0
}

func (x *MuxPreambleRequest) GetPolicy() *BrokerWirePolicy {
	if x != nil {
		return x.Policy
	}
	return nil
}

// MuxPreambleResponse is the daemon's first frame: acceptance carrying the
// effective (minimum) ceilings, the authenticated daemon identity and
// incarnation, and the accepted policy, or a typed refusal. The effective
// ceilings never exceed the client's offer, and max_aggregate_bytes stays a
// per-direction budget: the daemon enforces the effective value
// independently in each direction it buffers.
type MuxPreambleResponse struct {
	state                   protoimpl.MessageState `protogen:"open.v1"`
	Magic                   uint32                 `protobuf:"varint,1,opt,name=magic,proto3" json:"magic,omitempty"`
	Epoch                   uint32                 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Version                 uint32                 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
	Role                    *PreambleRole          `protobuf:"bytes,4,opt,name=role,proto3" json:"role,omitempty"`                                                                           // must be 6 (daemonmux server)
	MaxReceiveEnvelopeBytes uint64                 `protobuf:"varint,5,opt,name=max_receive_envelope_bytes,json=maxReceiveEnvelopeBytes,proto3" json:"max_receive_envelope_bytes,omitempty"` // effective ceiling
	StreamChunkLimit        uint64                 `protobuf:"varint,6,opt,name=stream_chunk_limit,json=streamChunkLimit,proto3" json:"stream_chunk_limit,omitempty"`                        // effective ceiling
	MaxStreams              uint64                 `protobuf:"varint,7,opt,name=max_streams,json=maxStreams,proto3" json:"max_streams,omitempty"`                                            // effective ceiling
	MaxAggregateBytes       uint64                 `protobuf:"varint,8,opt,name=max_aggregate_bytes,json=maxAggregateBytes,proto3" json:"max_aggregate_bytes,omitempty"`                     // effective ceiling, per direction, never above the offer
	CapabilityBits          uint32                 `protobuf:"varint,9,opt,name=capability_bits,json=capabilityBits,proto3" json:"capability_bits,omitempty"`                                // must be zero
	AcceptedPolicy          *BrokerWirePolicy      `protobuf:"bytes,10,opt,name=accepted_policy,json=acceptedPolicy,proto3" json:"accepted_policy,omitempty"`                                // daemon-authoritative policy
	Accepted                bool                   `protobuf:"varint,11,opt,name=accepted,proto3" json:"accepted,omitempty"`
	Rejection               *PreambleRejectionCode `protobuf:"bytes,12,opt,name=rejection,proto3" json:"rejection,omitempty"`                                 // set only when accepted is false
	DaemonIdentity          string                 `protobuf:"bytes,13,opt,name=daemon_identity,json=daemonIdentity,proto3" json:"daemon_identity,omitempty"` // authenticated identity token
	Incarnation             []byte                 `protobuf:"bytes,14,opt,name=incarnation,proto3" json:"incarnation,omitempty"`                             // exactly 16 bytes
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

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

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

func (*MuxPreambleResponse) ProtoMessage() {}

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

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

func (x *MuxPreambleResponse) GetMagic() uint32 {
	if x != nil {
		return x.Magic
	}
	return 0
}

func (x *MuxPreambleResponse) GetEpoch() uint32 {
	if x != nil {
		return x.Epoch
	}
	return 0
}

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

func (x *MuxPreambleResponse) GetRole() *PreambleRole {
	if x != nil {
		return x.Role
	}
	return nil
}

func (x *MuxPreambleResponse) GetMaxReceiveEnvelopeBytes() uint64 {
	if x != nil {
		return x.MaxReceiveEnvelopeBytes
	}
	return 0
}

func (x *MuxPreambleResponse) GetStreamChunkLimit() uint64 {
	if x != nil {
		return x.StreamChunkLimit
	}
	return 0
}

func (x *MuxPreambleResponse) GetMaxStreams() uint64 {
	if x != nil {
		return x.MaxStreams
	}
	return 0
}

func (x *MuxPreambleResponse) GetMaxAggregateBytes() uint64 {
	if x != nil {
		return x.MaxAggregateBytes
	}
	return 0
}

func (x *MuxPreambleResponse) GetCapabilityBits() uint32 {
	if x != nil {
		return x.CapabilityBits
	}
	return 0
}

func (x *MuxPreambleResponse) GetAcceptedPolicy() *BrokerWirePolicy {
	if x != nil {
		return x.AcceptedPolicy
	}
	return nil
}

func (x *MuxPreambleResponse) GetAccepted() bool {
	if x != nil {
		return x.Accepted
	}
	return false
}

func (x *MuxPreambleResponse) GetRejection() *PreambleRejectionCode {
	if x != nil {
		return x.Rejection
	}
	return nil
}

func (x *MuxPreambleResponse) GetDaemonIdentity() string {
	if x != nil {
		return x.DaemonIdentity
	}
	return ""
}

func (x *MuxPreambleResponse) GetIncarnation() []byte {
	if x != nil {
		return x.Incarnation
	}
	return nil
}

var File_multiplex_proto protoreflect.FileDescriptor

const file_multiplex_proto_rawDesc = "" +
	"\n" +
	"\x0fmultiplex.proto\x12\vvev.wire.v1\x1a\fbroker.proto\x1a\fcommon.proto\x1a\x0eenvelope.proto\"\xae\x01\n" +
	"\fMuxStreamRef\x12,\n" +
	"\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\x12!\n" +
	"\fbroker_epoch\x18\x02 \x01(\x04R\vbrokerEpoch\x12#\n" +
	"\rconnection_id\x18\x03 \x01(\fR\fconnectionId\x12(\n" +
	"\x10client_stream_id\x18\x04 \x01(\x04R\x0eclientStreamId\"\x93\x03\n" +
	"\aMuxOpen\x12+\n" +
	"\x03ref\x18\x01 \x01(\v2\x19.vev.wire.v1.MuxStreamRefR\x03ref\x12\x18\n" +
	"\apurpose\x18\x02 \x01(\rR\apurpose\x12\x14\n" +
	"\x05local\x18\x03 \x01(\bR\x05local\x12\x1a\n" +
	"\bendpoint\x18\x04 \x01(\tR\bendpoint\x12C\n" +
	"\fregistration\x18\x05 \x01(\v2\x1f.vev.wire.v1.RemoteRegistrationR\fregistration\x120\n" +
	"\x06target\x18\x06 \x01(\v2\x18.vev.wire.v1.ExactTargetR\x06target\x12\x10\n" +
	"\x03env\x18\a \x03(\tR\x03env\x125\n" +
	"\x06policy\x18\b \x01(\v2\x1d.vev.wire.v1.BrokerWirePolicyR\x06policy\x12\x1c\n" +
	"\tadmission\x18\t \x01(\rR\tadmission\x12\x12\n" +
	"\x04name\x18\n" +
	" \x01(\tR\x04name\x12\x1d\n" +
	"\n" +
	"start_mode\x18\v \x01(\rR\tstartMode\"8\n" +
	"\tMuxOpened\x12+\n" +
	"\x03ref\x18\x01 \x01(\v2\x19.vev.wire.v1.MuxStreamRefR\x03ref\"o\n" +
	"\n" +
	"MuxRefused\x12+\n" +
	"\x03ref\x18\x01 \x01(\v2\x19.vev.wire.v1.MuxStreamRefR\x03ref\x124\n" +
	"\x05error\x18\x02 \x01(\v2\x1e.vev.wire.v1.BrokerErrorDetailR\x05error\"K\n" +
	"\aMuxData\x12,\n" +
	"\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\"8\n" +
	"\bMuxClose\x12,\n" +
	"\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\"n\n" +
	"\bMuxReset\x12,\n" +
	"\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\x124\n" +
	"\x05error\x18\x02 \x01(\v2\x1e.vev.wire.v1.BrokerErrorDetailR\x05error\"b\n" +
	"\x0fMuxWindowUpdate\x12,\n" +
	"\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\x12!\n" +
	"\fcredit_bytes\x18\x02 \x01(\x04R\vcreditBytes\"\x9e\x02\n" +
	"\x11MuxClientEnvelope\x12+\n" +
	"\x04open\x18\xad\x02 \x01(\v2\x14.vev.wire.v1.MuxOpenH\x00R\x04open\x12+\n" +
	"\x04data\x18\xae\x02 \x01(\v2\x14.vev.wire.v1.MuxDataH\x00R\x04data\x12.\n" +
	"\x05close\x18\xaf\x02 \x01(\v2\x15.vev.wire.v1.MuxCloseH\x00R\x05close\x12.\n" +
	"\x05reset\x18\xb0\x02 \x01(\v2\x15.vev.wire.v1.MuxResetH\x00R\x05reset\x12D\n" +
	"\rwindow_update\x18\xb1\x02 \x01(\v2\x1c.vev.wire.v1.MuxWindowUpdateH\x00R\fwindowUpdateB\t\n" +
	"\apayload\"\xda\x02\n" +
	"\x11MuxServerEnvelope\x121\n" +
	"\x06opened\x18\x91\x03 \x01(\v2\x16.vev.wire.v1.MuxOpenedH\x00R\x06opened\x124\n" +
	"\arefused\x18\x92\x03 \x01(\v2\x17.vev.wire.v1.MuxRefusedH\x00R\arefused\x12+\n" +
	"\x04data\x18\x93\x03 \x01(\v2\x14.vev.wire.v1.MuxDataH\x00R\x04data\x12.\n" +
	"\x05close\x18\x94\x03 \x01(\v2\x15.vev.wire.v1.MuxCloseH\x00R\x05close\x12.\n" +
	"\x05reset\x18\x95\x03 \x01(\v2\x15.vev.wire.v1.MuxResetH\x00R\x05reset\x12D\n" +
	"\rwindow_update\x18\x96\x03 \x01(\v2\x1c.vev.wire.v1.MuxWindowUpdateH\x00R\fwindowUpdateB\t\n" +
	"\apayload\"\xa5\x03\n" +
	"\x12MuxPreambleRequest\x12\x14\n" +
	"\x05magic\x18\x01 \x01(\rR\x05magic\x12\x14\n" +
	"\x05epoch\x18\x02 \x01(\rR\x05epoch\x12\x18\n" +
	"\aversion\x18\x03 \x01(\rR\aversion\x12-\n" +
	"\x04role\x18\x04 \x01(\v2\x19.vev.wire.v1.PreambleRoleR\x04role\x12;\n" +
	"\x1amax_receive_envelope_bytes\x18\x05 \x01(\x04R\x17maxReceiveEnvelopeBytes\x12,\n" +
	"\x12stream_chunk_limit\x18\x06 \x01(\x04R\x10streamChunkLimit\x12\x1f\n" +
	"\vmax_streams\x18\a \x01(\x04R\n" +
	"maxStreams\x12.\n" +
	"\x13max_aggregate_bytes\x18\b \x01(\x04R\x11maxAggregateBytes\x12'\n" +
	"\x0fcapability_bits\x18\t \x01(\rR\x0ecapabilityBits\x125\n" +
	"\x06policy\x18\n" +
	" \x01(\v2\x1d.vev.wire.v1.BrokerWirePolicyR\x06policy\"\xe0\x04\n" +
	"\x13MuxPreambleResponse\x12\x14\n" +
	"\x05magic\x18\x01 \x01(\rR\x05magic\x12\x14\n" +
	"\x05epoch\x18\x02 \x01(\rR\x05epoch\x12\x18\n" +
	"\aversion\x18\x03 \x01(\rR\aversion\x12-\n" +
	"\x04role\x18\x04 \x01(\v2\x19.vev.wire.v1.PreambleRoleR\x04role\x12;\n" +
	"\x1amax_receive_envelope_bytes\x18\x05 \x01(\x04R\x17maxReceiveEnvelopeBytes\x12,\n" +
	"\x12stream_chunk_limit\x18\x06 \x01(\x04R\x10streamChunkLimit\x12\x1f\n" +
	"\vmax_streams\x18\a \x01(\x04R\n" +
	"maxStreams\x12.\n" +
	"\x13max_aggregate_bytes\x18\b \x01(\x04R\x11maxAggregateBytes\x12'\n" +
	"\x0fcapability_bits\x18\t \x01(\rR\x0ecapabilityBits\x12F\n" +
	"\x0faccepted_policy\x18\n" +
	" \x01(\v2\x1d.vev.wire.v1.BrokerWirePolicyR\x0eacceptedPolicy\x12\x1a\n" +
	"\baccepted\x18\v \x01(\bR\baccepted\x12@\n" +
	"\trejection\x18\f \x01(\v2\".vev.wire.v1.PreambleRejectionCodeR\trejection\x12'\n" +
	"\x0fdaemon_identity\x18\r \x01(\tR\x0edaemonIdentity\x12 \n" +
	"\vincarnation\x18\x0e \x01(\fR\vincarnationB-Z+github.com/bnema/vev/internal/protocol/wireb\x06proto3"

var (
	file_multiplex_proto_rawDescOnce sync.Once
	file_multiplex_proto_rawDescData []byte
)

func file_multiplex_proto_rawDescGZIP() []byte {
	file_multiplex_proto_rawDescOnce.Do(func() {
		file_multiplex_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_multiplex_proto_rawDesc), len(file_multiplex_proto_rawDesc)))
	})
	return file_multiplex_proto_rawDescData
}

var file_multiplex_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_multiplex_proto_goTypes = []any{
	(*MuxStreamRef)(nil),          // 0: vev.wire.v1.MuxStreamRef
	(*MuxOpen)(nil),               // 1: vev.wire.v1.MuxOpen
	(*MuxOpened)(nil),             // 2: vev.wire.v1.MuxOpened
	(*MuxRefused)(nil),            // 3: vev.wire.v1.MuxRefused
	(*MuxData)(nil),               // 4: vev.wire.v1.MuxData
	(*MuxClose)(nil),              // 5: vev.wire.v1.MuxClose
	(*MuxReset)(nil),              // 6: vev.wire.v1.MuxReset
	(*MuxWindowUpdate)(nil),       // 7: vev.wire.v1.MuxWindowUpdate
	(*MuxClientEnvelope)(nil),     // 8: vev.wire.v1.MuxClientEnvelope
	(*MuxServerEnvelope)(nil),     // 9: vev.wire.v1.MuxServerEnvelope
	(*MuxPreambleRequest)(nil),    // 10: vev.wire.v1.MuxPreambleRequest
	(*MuxPreambleResponse)(nil),   // 11: vev.wire.v1.MuxPreambleResponse
	(*RemoteRegistration)(nil),    // 12: vev.wire.v1.RemoteRegistration
	(*ExactTarget)(nil),           // 13: vev.wire.v1.ExactTarget
	(*BrokerWirePolicy)(nil),      // 14: vev.wire.v1.BrokerWirePolicy
	(*BrokerErrorDetail)(nil),     // 15: vev.wire.v1.BrokerErrorDetail
	(*PreambleRole)(nil),          // 16: vev.wire.v1.PreambleRole
	(*PreambleRejectionCode)(nil), // 17: vev.wire.v1.PreambleRejectionCode
}
var file_multiplex_proto_depIdxs = []int32{
	0,  // 0: vev.wire.v1.MuxOpen.ref:type_name -> vev.wire.v1.MuxStreamRef
	12, // 1: vev.wire.v1.MuxOpen.registration:type_name -> vev.wire.v1.RemoteRegistration
	13, // 2: vev.wire.v1.MuxOpen.target:type_name -> vev.wire.v1.ExactTarget
	14, // 3: vev.wire.v1.MuxOpen.policy:type_name -> vev.wire.v1.BrokerWirePolicy
	0,  // 4: vev.wire.v1.MuxOpened.ref:type_name -> vev.wire.v1.MuxStreamRef
	0,  // 5: vev.wire.v1.MuxRefused.ref:type_name -> vev.wire.v1.MuxStreamRef
	15, // 6: vev.wire.v1.MuxRefused.error:type_name -> vev.wire.v1.BrokerErrorDetail
	15, // 7: vev.wire.v1.MuxReset.error:type_name -> vev.wire.v1.BrokerErrorDetail
	1,  // 8: vev.wire.v1.MuxClientEnvelope.open:type_name -> vev.wire.v1.MuxOpen
	4,  // 9: vev.wire.v1.MuxClientEnvelope.data:type_name -> vev.wire.v1.MuxData
	5,  // 10: vev.wire.v1.MuxClientEnvelope.close:type_name -> vev.wire.v1.MuxClose
	6,  // 11: vev.wire.v1.MuxClientEnvelope.reset:type_name -> vev.wire.v1.MuxReset
	7,  // 12: vev.wire.v1.MuxClientEnvelope.window_update:type_name -> vev.wire.v1.MuxWindowUpdate
	2,  // 13: vev.wire.v1.MuxServerEnvelope.opened:type_name -> vev.wire.v1.MuxOpened
	3,  // 14: vev.wire.v1.MuxServerEnvelope.refused:type_name -> vev.wire.v1.MuxRefused
	4,  // 15: vev.wire.v1.MuxServerEnvelope.data:type_name -> vev.wire.v1.MuxData
	5,  // 16: vev.wire.v1.MuxServerEnvelope.close:type_name -> vev.wire.v1.MuxClose
	6,  // 17: vev.wire.v1.MuxServerEnvelope.reset:type_name -> vev.wire.v1.MuxReset
	7,  // 18: vev.wire.v1.MuxServerEnvelope.window_update:type_name -> vev.wire.v1.MuxWindowUpdate
	16, // 19: vev.wire.v1.MuxPreambleRequest.role:type_name -> vev.wire.v1.PreambleRole
	14, // 20: vev.wire.v1.MuxPreambleRequest.policy:type_name -> vev.wire.v1.BrokerWirePolicy
	16, // 21: vev.wire.v1.MuxPreambleResponse.role:type_name -> vev.wire.v1.PreambleRole
	14, // 22: vev.wire.v1.MuxPreambleResponse.accepted_policy:type_name -> vev.wire.v1.BrokerWirePolicy
	17, // 23: vev.wire.v1.MuxPreambleResponse.rejection:type_name -> vev.wire.v1.PreambleRejectionCode
	24, // [24:24] is the sub-list for method output_type
	24, // [24:24] is the sub-list for method input_type
	24, // [24:24] is the sub-list for extension type_name
	24, // [24:24] is the sub-list for extension extendee
	0,  // [0:24] is the sub-list for field type_name
}

func init() { file_multiplex_proto_init() }
func file_multiplex_proto_init() {
	if File_multiplex_proto != nil {
		return
	}
	file_broker_proto_init()
	file_common_proto_init()
	file_envelope_proto_init()
	file_multiplex_proto_msgTypes[8].OneofWrappers = []any{
		(*MuxClientEnvelope_Open)(nil),
		(*MuxClientEnvelope_Data)(nil),
		(*MuxClientEnvelope_Close)(nil),
		(*MuxClientEnvelope_Reset_)(nil),
		(*MuxClientEnvelope_WindowUpdate)(nil),
	}
	file_multiplex_proto_msgTypes[9].OneofWrappers = []any{
		(*MuxServerEnvelope_Opened)(nil),
		(*MuxServerEnvelope_Refused)(nil),
		(*MuxServerEnvelope_Data)(nil),
		(*MuxServerEnvelope_Close)(nil),
		(*MuxServerEnvelope_Reset_)(nil),
		(*MuxServerEnvelope_WindowUpdate)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_multiplex_proto_rawDesc), len(file_multiplex_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   12,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_multiplex_proto_goTypes,
		DependencyIndexes: file_multiplex_proto_depIdxs,
		MessageInfos:      file_multiplex_proto_msgTypes,
	}.Build()
	File_multiplex_proto = out.File
	file_multiplex_proto_goTypes = nil
	file_multiplex_proto_depIdxs = nil
}