// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.9
// 	protoc        v6.32.1
// source: internal/tunnel/rpc/rpc.proto

package rpc

import (
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"

	_ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
	_ "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tool/grpctool/automata"
	info "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tunnel/info"
	status "google.golang.org/genproto/googleapis/rpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
)

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

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

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

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

func (*StartStreaming) ProtoMessage() {}

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

type MetadataValues struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Value         [][]byte               `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetadataValues) ProtoMessage() {}

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

func (x *MetadataValues) GetValue() [][]byte {
	if x != nil {
		return x.Value
	}
	return nil
}

type MetadataKV struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           []byte                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value         *MetadataValues        `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetadataKV) ProtoMessage() {}

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

func (x *MetadataKV) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *MetadataKV) GetValue() *MetadataValues {
	if x != nil {
		return x.Value
	}
	return nil
}

type GatewayResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Msg:
	//
	//	*GatewayResponse_TunnelReady_
	//	*GatewayResponse_Header_
	//	*GatewayResponse_Message_
	//	*GatewayResponse_Trailer_
	//	*GatewayResponse_Error_
	//	*GatewayResponse_NoTunnel_
	Msg           isGatewayResponse_Msg `protobuf_oneof:"msg"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GatewayResponse) ProtoMessage() {}

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

func (x *GatewayResponse) GetMsg() isGatewayResponse_Msg {
	if x != nil {
		return x.Msg
	}
	return nil
}

func (x *GatewayResponse) GetTunnelReady() *GatewayResponse_TunnelReady {
	if x != nil {
		if x, ok := x.Msg.(*GatewayResponse_TunnelReady_); ok {
			return x.TunnelReady
		}
	}
	return nil
}

func (x *GatewayResponse) GetHeader() *GatewayResponse_Header {
	if x != nil {
		if x, ok := x.Msg.(*GatewayResponse_Header_); ok {
			return x.Header
		}
	}
	return nil
}

func (x *GatewayResponse) GetMessage() *GatewayResponse_Message {
	if x != nil {
		if x, ok := x.Msg.(*GatewayResponse_Message_); ok {
			return x.Message
		}
	}
	return nil
}

func (x *GatewayResponse) GetTrailer() *GatewayResponse_Trailer {
	if x != nil {
		if x, ok := x.Msg.(*GatewayResponse_Trailer_); ok {
			return x.Trailer
		}
	}
	return nil
}

func (x *GatewayResponse) GetError() *GatewayResponse_Error {
	if x != nil {
		if x, ok := x.Msg.(*GatewayResponse_Error_); ok {
			return x.Error
		}
	}
	return nil
}

func (x *GatewayResponse) GetNoTunnel() *GatewayResponse_NoTunnel {
	if x != nil {
		if x, ok := x.Msg.(*GatewayResponse_NoTunnel_); ok {
			return x.NoTunnel
		}
	}
	return nil
}

type isGatewayResponse_Msg interface {
	isGatewayResponse_Msg()
}

type GatewayResponse_TunnelReady_ struct {
	TunnelReady *GatewayResponse_TunnelReady `protobuf:"bytes,1,opt,name=tunnel_ready,json=tunnelReady,proto3,oneof"`
}

type GatewayResponse_Header_ struct {
	Header *GatewayResponse_Header `protobuf:"bytes,2,opt,name=header,proto3,oneof"`
}

type GatewayResponse_Message_ struct {
	Message *GatewayResponse_Message `protobuf:"bytes,3,opt,name=message,proto3,oneof"`
}

type GatewayResponse_Trailer_ struct {
	Trailer *GatewayResponse_Trailer `protobuf:"bytes,4,opt,name=trailer,proto3,oneof"`
}

type GatewayResponse_Error_ struct {
	Error *GatewayResponse_Error `protobuf:"bytes,5,opt,name=error,proto3,oneof"`
}

type GatewayResponse_NoTunnel_ struct {
	NoTunnel *GatewayResponse_NoTunnel `protobuf:"bytes,6,opt,name=no_tunnel,json=noTunnel,proto3,oneof"`
}

func (*GatewayResponse_TunnelReady_) isGatewayResponse_Msg() {}

func (*GatewayResponse_Header_) isGatewayResponse_Msg() {}

func (*GatewayResponse_Message_) isGatewayResponse_Msg() {}

func (*GatewayResponse_Trailer_) isGatewayResponse_Msg() {}

func (*GatewayResponse_Error_) isGatewayResponse_Msg() {}

func (*GatewayResponse_NoTunnel_) isGatewayResponse_Msg() {}

type Descriptor struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ApiDescriptor *info.APIDescriptor    `protobuf:"bytes,1,opt,name=api_descriptor,json=apiDescriptor,proto3" json:"api_descriptor,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Descriptor) ProtoMessage() {}

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

func (x *Descriptor) GetApiDescriptor() *info.APIDescriptor {
	if x != nil {
		return x.ApiDescriptor
	}
	return nil
}

type Header struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Meta          []*MetadataKV          `protobuf:"bytes,1,rep,name=meta,proto3" json:"meta,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Header) ProtoMessage() {}

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

func (x *Header) GetMeta() []*MetadataKV {
	if x != nil {
		return x.Meta
	}
	return nil
}

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

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

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

func (*Message) ProtoMessage() {}

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

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

type Trailer struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Meta          []*MetadataKV          `protobuf:"bytes,1,rep,name=meta,proto3" json:"meta,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Trailer) ProtoMessage() {}

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

func (x *Trailer) GetMeta() []*MetadataKV {
	if x != nil {
		return x.Meta
	}
	return nil
}

type Error struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        *status.Status         `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Error) ProtoMessage() {}

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

func (x *Error) GetStatus() *status.Status {
	if x != nil {
		return x.Status
	}
	return nil
}

type ConnectRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Msg:
	//
	//	*ConnectRequest_Descriptor_
	//	*ConnectRequest_Header
	//	*ConnectRequest_Message
	//	*ConnectRequest_Trailer
	//	*ConnectRequest_Error
	Msg           isConnectRequest_Msg `protobuf_oneof:"msg"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ConnectRequest) ProtoMessage() {}

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

func (x *ConnectRequest) GetMsg() isConnectRequest_Msg {
	if x != nil {
		return x.Msg
	}
	return nil
}

func (x *ConnectRequest) GetDescriptor_() *Descriptor {
	if x != nil {
		if x, ok := x.Msg.(*ConnectRequest_Descriptor_); ok {
			return x.Descriptor_
		}
	}
	return nil
}

func (x *ConnectRequest) GetHeader() *Header {
	if x != nil {
		if x, ok := x.Msg.(*ConnectRequest_Header); ok {
			return x.Header
		}
	}
	return nil
}

func (x *ConnectRequest) GetMessage() *Message {
	if x != nil {
		if x, ok := x.Msg.(*ConnectRequest_Message); ok {
			return x.Message
		}
	}
	return nil
}

func (x *ConnectRequest) GetTrailer() *Trailer {
	if x != nil {
		if x, ok := x.Msg.(*ConnectRequest_Trailer); ok {
			return x.Trailer
		}
	}
	return nil
}

func (x *ConnectRequest) GetError() *Error {
	if x != nil {
		if x, ok := x.Msg.(*ConnectRequest_Error); ok {
			return x.Error
		}
	}
	return nil
}

type isConnectRequest_Msg interface {
	isConnectRequest_Msg()
}

type ConnectRequest_Descriptor_ struct {
	Descriptor_ *Descriptor `protobuf:"bytes,1,opt,name=descriptor,proto3,oneof"`
}

type ConnectRequest_Header struct {
	Header *Header `protobuf:"bytes,2,opt,name=header,proto3,oneof"`
}

type ConnectRequest_Message struct {
	Message *Message `protobuf:"bytes,3,opt,name=message,proto3,oneof"`
}

type ConnectRequest_Trailer struct {
	Trailer *Trailer `protobuf:"bytes,4,opt,name=trailer,proto3,oneof"`
}

type ConnectRequest_Error struct {
	Error *Error `protobuf:"bytes,5,opt,name=error,proto3,oneof"`
}

func (*ConnectRequest_Descriptor_) isConnectRequest_Msg() {}

func (*ConnectRequest_Header) isConnectRequest_Msg() {}

func (*ConnectRequest_Message) isConnectRequest_Msg() {}

func (*ConnectRequest_Trailer) isConnectRequest_Msg() {}

func (*ConnectRequest_Error) isConnectRequest_Msg() {}

type RequestInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	MethodName    string                 `protobuf:"bytes,1,opt,name=method_name,json=methodName,proto3" json:"method_name,omitempty"`
	Meta          []*MetadataKV          `protobuf:"bytes,2,rep,name=meta,proto3" json:"meta,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RequestInfo) ProtoMessage() {}

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

func (x *RequestInfo) GetMethodName() string {
	if x != nil {
		return x.MethodName
	}
	return ""
}

func (x *RequestInfo) GetMeta() []*MetadataKV {
	if x != nil {
		return x.Meta
	}
	return nil
}

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

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

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

func (*CloseSend) ProtoMessage() {}

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

type ConnectResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Msg:
	//
	//	*ConnectResponse_RequestInfo
	//	*ConnectResponse_Message
	//	*ConnectResponse_CloseSend
	Msg           isConnectResponse_Msg `protobuf_oneof:"msg"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ConnectResponse) ProtoMessage() {}

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

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

func (x *ConnectResponse) GetMsg() isConnectResponse_Msg {
	if x != nil {
		return x.Msg
	}
	return nil
}

func (x *ConnectResponse) GetRequestInfo() *RequestInfo {
	if x != nil {
		if x, ok := x.Msg.(*ConnectResponse_RequestInfo); ok {
			return x.RequestInfo
		}
	}
	return nil
}

func (x *ConnectResponse) GetMessage() *Message {
	if x != nil {
		if x, ok := x.Msg.(*ConnectResponse_Message); ok {
			return x.Message
		}
	}
	return nil
}

func (x *ConnectResponse) GetCloseSend() *CloseSend {
	if x != nil {
		if x, ok := x.Msg.(*ConnectResponse_CloseSend); ok {
			return x.CloseSend
		}
	}
	return nil
}

type isConnectResponse_Msg interface {
	isConnectResponse_Msg()
}

type ConnectResponse_RequestInfo struct {
	RequestInfo *RequestInfo `protobuf:"bytes,1,opt,name=request_info,json=requestInfo,proto3,oneof"`
}

type ConnectResponse_Message struct {
	Message *Message `protobuf:"bytes,2,opt,name=message,proto3,oneof"`
}

type ConnectResponse_CloseSend struct {
	CloseSend *CloseSend `protobuf:"bytes,3,opt,name=close_send,json=closeSend,proto3,oneof"`
}

func (*ConnectResponse_RequestInfo) isConnectResponse_Msg() {}

func (*ConnectResponse_Message) isConnectResponse_Msg() {}

func (*ConnectResponse_CloseSend) isConnectResponse_Msg() {}

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

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

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

func (*GatewayResponse_TunnelReady) ProtoMessage() {}

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

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

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

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

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

func (*GatewayResponse_NoTunnel) ProtoMessage() {}

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

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

type GatewayResponse_Header struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Meta          []*MetadataKV          `protobuf:"bytes,1,rep,name=meta,proto3" json:"meta,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GatewayResponse_Header) ProtoMessage() {}

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

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

func (x *GatewayResponse_Header) GetMeta() []*MetadataKV {
	if x != nil {
		return x.Meta
	}
	return nil
}

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

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

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

func (*GatewayResponse_Message) ProtoMessage() {}

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

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

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

type GatewayResponse_Trailer struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Meta          []*MetadataKV          `protobuf:"bytes,1,rep,name=meta,proto3" json:"meta,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GatewayResponse_Trailer) ProtoMessage() {}

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

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

func (x *GatewayResponse_Trailer) GetMeta() []*MetadataKV {
	if x != nil {
		return x.Meta
	}
	return nil
}

type GatewayResponse_Error struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        *status.Status         `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GatewayResponse_Error) ProtoMessage() {}

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

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

func (x *GatewayResponse_Error) GetStatus() *status.Status {
	if x != nil {
		return x.Status
	}
	return nil
}

var File_internal_tunnel_rpc_rpc_proto protoreflect.FileDescriptor

const file_internal_tunnel_rpc_rpc_proto_rawDesc = "" +
	"\n" +
	"\x1dinternal/tunnel/rpc/rpc.proto\x12\x1fgitlab.agent.reverse_tunnel.rpc\x1a.internal/tool/grpctool/automata/automata.proto\x1a\x1finternal/tunnel/info/info.proto\x1a\x1bbuf/validate/validate.proto\x1a\x17google/rpc/status.proto\"\x10\n" +
	"\x0eStartStreaming\"0\n" +
	"\x0eMetadataValues\x12\x1e\n" +
	"\x05value\x18\x01 \x03(\fB\b\xbaH\x05\x92\x01\x02\b\x01R\x05value\"\xa5\x02\n" +
	"\n" +
	"MetadataKV\x12)\n" +
	"\x03key\x18\x01 \x01(\fB\x17\xbaH\x14z\x12\"\x10^:?[a-z0-9._-]+$R\x03key\x12M\n" +
	"\x05value\x18\x02 \x01(\v2/.gitlab.agent.reverse_tunnel.rpc.MetadataValuesB\x06\xbaH\x03\xc8\x01\x01R\x05value:\x9c\x01\xbaH\x98\x01\x1a\x95\x01\n" +
	"\x0evalid_metadata\x1a\x82\x01this.key.endsWith(bytes('-bin')) ? '': this.value.value.all(v, string(v).matches('^[\\x20-\\x7E]*$')) ? '': 'invalid metadata value'\"\x92\a\n" +
	"\x0fGatewayResponse\x12h\n" +
	"\ftunnel_ready\x18\x01 \x01(\v2<.gitlab.agent.reverse_tunnel.rpc.GatewayResponse.TunnelReadyB\x05\x82\xf6,\x01\x02H\x00R\vtunnelReady\x12Y\n" +
	"\x06header\x18\x02 \x01(\v27.gitlab.agent.reverse_tunnel.rpc.GatewayResponse.HeaderB\x06\x82\xf6,\x02\x03\x04H\x00R\x06header\x12\\\n" +
	"\amessage\x18\x03 \x01(\v28.gitlab.agent.reverse_tunnel.rpc.GatewayResponse.MessageB\x06\x82\xf6,\x02\x03\x04H\x00R\amessage\x12e\n" +
	"\atrailer\x18\x04 \x01(\v28.gitlab.agent.reverse_tunnel.rpc.GatewayResponse.TrailerB\x0f\x82\xf6,\v\x05\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01H\x00R\atrailer\x12^\n" +
	"\x05error\x18\x05 \x01(\v26.gitlab.agent.reverse_tunnel.rpc.GatewayResponse.ErrorB\x0e\x82\xf6,\n" +
	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01H\x00R\x05error\x12i\n" +
	"\tno_tunnel\x18\x06 \x01(\v29.gitlab.agent.reverse_tunnel.rpc.GatewayResponse.NoTunnelB\x0f\x82\xf6,\v\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01H\x00R\bnoTunnel\x1a\r\n" +
	"\vTunnelReady\x1a\n" +
	"\n" +
	"\bNoTunnel\x1aI\n" +
	"\x06Header\x12?\n" +
	"\x04meta\x18\x01 \x03(\v2+.gitlab.agent.reverse_tunnel.rpc.MetadataKVR\x04meta\x1a\x1d\n" +
	"\aMessage\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\x1aJ\n" +
	"\aTrailer\x12?\n" +
	"\x04meta\x18\x01 \x03(\v2+.gitlab.agent.reverse_tunnel.rpc.MetadataKVR\x04meta\x1a;\n" +
	"\x05Error\x122\n" +
	"\x06status\x18\x01 \x01(\v2\x12.google.rpc.StatusB\x06\xbaH\x03\xc8\x01\x01R\x06statusB\x1c\n" +
	"\x03msg\x12\x15\xbaH\x02\b\x01\x8a\xf6,\f\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x06\"l\n" +
	"\n" +
	"Descriptor\x12^\n" +
	"\x0eapi_descriptor\x18\x01 \x01(\v2/.gitlab.agent.reverse_tunnel.info.APIDescriptorB\x06\xbaH\x03\xc8\x01\x01R\rapiDescriptor\"I\n" +
	"\x06Header\x12?\n" +
	"\x04meta\x18\x01 \x03(\v2+.gitlab.agent.reverse_tunnel.rpc.MetadataKVR\x04meta\"\x1d\n" +
	"\aMessage\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"J\n" +
	"\aTrailer\x12?\n" +
	"\x04meta\x18\x01 \x03(\v2+.gitlab.agent.reverse_tunnel.rpc.MetadataKVR\x04meta\";\n" +
	"\x05Error\x122\n" +
	"\x06status\x18\x01 \x01(\v2\x12.google.rpc.StatusB\x06\xbaH\x03\xc8\x01\x01R\x06status\"\xba\x03\n" +
	"\x0eConnectRequest\x12U\n" +
	"\n" +
	"descriptor\x18\x01 \x01(\v2+.gitlab.agent.reverse_tunnel.rpc.DescriptorB\x06\x82\xf6,\x02\x02\x05H\x00R\n" +
	"descriptor\x12I\n" +
	"\x06header\x18\x02 \x01(\v2'.gitlab.agent.reverse_tunnel.rpc.HeaderB\x06\x82\xf6,\x02\x03\x04H\x00R\x06header\x12L\n" +
	"\amessage\x18\x03 \x01(\v2(.gitlab.agent.reverse_tunnel.rpc.MessageB\x06\x82\xf6,\x02\x03\x04H\x00R\amessage\x12U\n" +
	"\atrailer\x18\x04 \x01(\v2(.gitlab.agent.reverse_tunnel.rpc.TrailerB\x0f\x82\xf6,\v\x05\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01H\x00R\atrailer\x12N\n" +
	"\x05error\x18\x05 \x01(\v2&.gitlab.agent.reverse_tunnel.rpc.ErrorB\x0e\x82\xf6,\n" +
	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01H\x00R\x05errorB\x11\n" +
	"\x03msg\x12\n" +
	"\xbaH\x02\b\x01\x8a\xf6,\x01\x01\"x\n" +
	"\vRequestInfo\x12(\n" +
	"\vmethod_name\x18\x01 \x01(\tB\a\xbaH\x04r\x02 \x01R\n" +
	"methodName\x12?\n" +
	"\x04meta\x18\x02 \x03(\v2+.gitlab.agent.reverse_tunnel.rpc.MetadataKVR\x04meta\"\v\n" +
	"\tCloseSend\"\xc8\x02\n" +
	"\x0fConnectResponse\x12c\n" +
	"\frequest_info\x18\x01 \x01(\v2,.gitlab.agent.reverse_tunnel.rpc.RequestInfoB\x10\x82\xf6,\f\x02\x03\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01H\x00R\vrequestInfo\x12V\n" +
	"\amessage\x18\x02 \x01(\v2(.gitlab.agent.reverse_tunnel.rpc.MessageB\x10\x82\xf6,\f\x02\x03\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01H\x00R\amessage\x12[\n" +
	"\n" +
	"close_send\x18\x03 \x01(\v2*.gitlab.agent.reverse_tunnel.rpc.CloseSendB\x0e\x82\xf6,\n" +
	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01H\x00R\tcloseSendB\x1b\n" +
	"\x03msg\x12\x14\xbaH\x02\b\x01\x8a\xf6,\v\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\x012\x83\x01\n" +
	"\rReverseTunnel\x12r\n" +
	"\aConnect\x12/.gitlab.agent.reverse_tunnel.rpc.ConnectRequest\x1a0.gitlab.agent.reverse_tunnel.rpc.ConnectResponse\"\x00(\x010\x01BPZNgitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tunnel/rpcb\x06proto3"

var (
	file_internal_tunnel_rpc_rpc_proto_rawDescOnce sync.Once
	file_internal_tunnel_rpc_rpc_proto_rawDescData []byte
)

func file_internal_tunnel_rpc_rpc_proto_rawDescGZIP() []byte {
	file_internal_tunnel_rpc_rpc_proto_rawDescOnce.Do(func() {
		file_internal_tunnel_rpc_rpc_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_tunnel_rpc_rpc_proto_rawDesc), len(file_internal_tunnel_rpc_rpc_proto_rawDesc)))
	})
	return file_internal_tunnel_rpc_rpc_proto_rawDescData
}

var file_internal_tunnel_rpc_rpc_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
var file_internal_tunnel_rpc_rpc_proto_goTypes = []any{
	(*StartStreaming)(nil),              // 0: gitlab.agent.reverse_tunnel.rpc.StartStreaming
	(*MetadataValues)(nil),              // 1: gitlab.agent.reverse_tunnel.rpc.MetadataValues
	(*MetadataKV)(nil),                  // 2: gitlab.agent.reverse_tunnel.rpc.MetadataKV
	(*GatewayResponse)(nil),             // 3: gitlab.agent.reverse_tunnel.rpc.GatewayResponse
	(*Descriptor)(nil),                  // 4: gitlab.agent.reverse_tunnel.rpc.Descriptor
	(*Header)(nil),                      // 5: gitlab.agent.reverse_tunnel.rpc.Header
	(*Message)(nil),                     // 6: gitlab.agent.reverse_tunnel.rpc.Message
	(*Trailer)(nil),                     // 7: gitlab.agent.reverse_tunnel.rpc.Trailer
	(*Error)(nil),                       // 8: gitlab.agent.reverse_tunnel.rpc.Error
	(*ConnectRequest)(nil),              // 9: gitlab.agent.reverse_tunnel.rpc.ConnectRequest
	(*RequestInfo)(nil),                 // 10: gitlab.agent.reverse_tunnel.rpc.RequestInfo
	(*CloseSend)(nil),                   // 11: gitlab.agent.reverse_tunnel.rpc.CloseSend
	(*ConnectResponse)(nil),             // 12: gitlab.agent.reverse_tunnel.rpc.ConnectResponse
	(*GatewayResponse_TunnelReady)(nil), // 13: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.TunnelReady
	(*GatewayResponse_NoTunnel)(nil),    // 14: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.NoTunnel
	(*GatewayResponse_Header)(nil),      // 15: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Header
	(*GatewayResponse_Message)(nil),     // 16: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Message
	(*GatewayResponse_Trailer)(nil),     // 17: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Trailer
	(*GatewayResponse_Error)(nil),       // 18: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Error
	(*info.APIDescriptor)(nil),          // 19: gitlab.agent.reverse_tunnel.info.APIDescriptor
	(*status.Status)(nil),               // 20: google.rpc.Status
}
var file_internal_tunnel_rpc_rpc_proto_depIdxs = []int32{
	1,  // 0: gitlab.agent.reverse_tunnel.rpc.MetadataKV.value:type_name -> gitlab.agent.reverse_tunnel.rpc.MetadataValues
	13, // 1: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.tunnel_ready:type_name -> gitlab.agent.reverse_tunnel.rpc.GatewayResponse.TunnelReady
	15, // 2: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.header:type_name -> gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Header
	16, // 3: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.message:type_name -> gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Message
	17, // 4: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.trailer:type_name -> gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Trailer
	18, // 5: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.error:type_name -> gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Error
	14, // 6: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.no_tunnel:type_name -> gitlab.agent.reverse_tunnel.rpc.GatewayResponse.NoTunnel
	19, // 7: gitlab.agent.reverse_tunnel.rpc.Descriptor.api_descriptor:type_name -> gitlab.agent.reverse_tunnel.info.APIDescriptor
	2,  // 8: gitlab.agent.reverse_tunnel.rpc.Header.meta:type_name -> gitlab.agent.reverse_tunnel.rpc.MetadataKV
	2,  // 9: gitlab.agent.reverse_tunnel.rpc.Trailer.meta:type_name -> gitlab.agent.reverse_tunnel.rpc.MetadataKV
	20, // 10: gitlab.agent.reverse_tunnel.rpc.Error.status:type_name -> google.rpc.Status
	4,  // 11: gitlab.agent.reverse_tunnel.rpc.ConnectRequest.descriptor:type_name -> gitlab.agent.reverse_tunnel.rpc.Descriptor
	5,  // 12: gitlab.agent.reverse_tunnel.rpc.ConnectRequest.header:type_name -> gitlab.agent.reverse_tunnel.rpc.Header
	6,  // 13: gitlab.agent.reverse_tunnel.rpc.ConnectRequest.message:type_name -> gitlab.agent.reverse_tunnel.rpc.Message
	7,  // 14: gitlab.agent.reverse_tunnel.rpc.ConnectRequest.trailer:type_name -> gitlab.agent.reverse_tunnel.rpc.Trailer
	8,  // 15: gitlab.agent.reverse_tunnel.rpc.ConnectRequest.error:type_name -> gitlab.agent.reverse_tunnel.rpc.Error
	2,  // 16: gitlab.agent.reverse_tunnel.rpc.RequestInfo.meta:type_name -> gitlab.agent.reverse_tunnel.rpc.MetadataKV
	10, // 17: gitlab.agent.reverse_tunnel.rpc.ConnectResponse.request_info:type_name -> gitlab.agent.reverse_tunnel.rpc.RequestInfo
	6,  // 18: gitlab.agent.reverse_tunnel.rpc.ConnectResponse.message:type_name -> gitlab.agent.reverse_tunnel.rpc.Message
	11, // 19: gitlab.agent.reverse_tunnel.rpc.ConnectResponse.close_send:type_name -> gitlab.agent.reverse_tunnel.rpc.CloseSend
	2,  // 20: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Header.meta:type_name -> gitlab.agent.reverse_tunnel.rpc.MetadataKV
	2,  // 21: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Trailer.meta:type_name -> gitlab.agent.reverse_tunnel.rpc.MetadataKV
	20, // 22: gitlab.agent.reverse_tunnel.rpc.GatewayResponse.Error.status:type_name -> google.rpc.Status
	9,  // 23: gitlab.agent.reverse_tunnel.rpc.ReverseTunnel.Connect:input_type -> gitlab.agent.reverse_tunnel.rpc.ConnectRequest
	12, // 24: gitlab.agent.reverse_tunnel.rpc.ReverseTunnel.Connect:output_type -> gitlab.agent.reverse_tunnel.rpc.ConnectResponse
	24, // [24:25] is the sub-list for method output_type
	23, // [23:24] is the sub-list for method input_type
	23, // [23:23] is the sub-list for extension type_name
	23, // [23:23] is the sub-list for extension extendee
	0,  // [0:23] is the sub-list for field type_name
}

func init() { file_internal_tunnel_rpc_rpc_proto_init() }
func file_internal_tunnel_rpc_rpc_proto_init() {
	if File_internal_tunnel_rpc_rpc_proto != nil {
		return
	}
	file_internal_tunnel_rpc_rpc_proto_msgTypes[3].OneofWrappers = []any{
		(*GatewayResponse_TunnelReady_)(nil),
		(*GatewayResponse_Header_)(nil),
		(*GatewayResponse_Message_)(nil),
		(*GatewayResponse_Trailer_)(nil),
		(*GatewayResponse_Error_)(nil),
		(*GatewayResponse_NoTunnel_)(nil),
	}
	file_internal_tunnel_rpc_rpc_proto_msgTypes[9].OneofWrappers = []any{
		(*ConnectRequest_Descriptor_)(nil),
		(*ConnectRequest_Header)(nil),
		(*ConnectRequest_Message)(nil),
		(*ConnectRequest_Trailer)(nil),
		(*ConnectRequest_Error)(nil),
	}
	file_internal_tunnel_rpc_rpc_proto_msgTypes[12].OneofWrappers = []any{
		(*ConnectResponse_RequestInfo)(nil),
		(*ConnectResponse_Message)(nil),
		(*ConnectResponse_CloseSend)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_tunnel_rpc_rpc_proto_rawDesc), len(file_internal_tunnel_rpc_rpc_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   19,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_internal_tunnel_rpc_rpc_proto_goTypes,
		DependencyIndexes: file_internal_tunnel_rpc_rpc_proto_depIdxs,
		MessageInfos:      file_internal_tunnel_rpc_rpc_proto_msgTypes,
	}.Build()
	File_internal_tunnel_rpc_rpc_proto = out.File
	file_internal_tunnel_rpc_rpc_proto_goTypes = nil
	file_internal_tunnel_rpc_rpc_proto_depIdxs = nil
}
