Xray-core/transport/internet/config.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.33.5
// source: transport/internet/config.proto

package internet

import (
	net "github.com/xtls/xray-core/common/net"
	serial "github.com/xtls/xray-core/common/serial"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

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

type DomainStrategy int32

const (
	DomainStrategy_AS_IS      DomainStrategy = 0
	DomainStrategy_USE_IP     DomainStrategy = 1
	DomainStrategy_USE_IP4    DomainStrategy = 2
	DomainStrategy_USE_IP6    DomainStrategy = 3
	DomainStrategy_USE_IP46   DomainStrategy = 4
	DomainStrategy_USE_IP64   DomainStrategy = 5
	DomainStrategy_FORCE_IP   DomainStrategy = 6
	DomainStrategy_FORCE_IP4  DomainStrategy = 7
	DomainStrategy_FORCE_IP6  DomainStrategy = 8
	DomainStrategy_FORCE_IP46 DomainStrategy = 9
	DomainStrategy_FORCE_IP64 DomainStrategy = 10
)

// Enum value maps for DomainStrategy.
var (
	DomainStrategy_name = map[int32]string{
		0:  "AS_IS",
		1:  "USE_IP",
		2:  "USE_IP4",
		3:  "USE_IP6",
		4:  "USE_IP46",
		5:  "USE_IP64",
		6:  "FORCE_IP",
		7:  "FORCE_IP4",
		8:  "FORCE_IP6",
		9:  "FORCE_IP46",
		10: "FORCE_IP64",
	}
	DomainStrategy_value = map[string]int32{
		"AS_IS":      0,
		"USE_IP":     1,
		"USE_IP4":    2,
		"USE_IP6":    3,
		"USE_IP46":   4,
		"USE_IP64":   5,
		"FORCE_IP":   6,
		"FORCE_IP4":  7,
		"FORCE_IP6":  8,
		"FORCE_IP46": 9,
		"FORCE_IP64": 10,
	}
)

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

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

func (DomainStrategy) Descriptor() protoreflect.EnumDescriptor {
	return file_transport_internet_config_proto_enumTypes[0].Descriptor()
}

func (DomainStrategy) Type() protoreflect.EnumType {
	return &file_transport_internet_config_proto_enumTypes[0]
}

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

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

type AddressPortStrategy int32

const (
	AddressPortStrategy_None              AddressPortStrategy = 0
	AddressPortStrategy_SrvPortOnly       AddressPortStrategy = 1
	AddressPortStrategy_SrvAddressOnly    AddressPortStrategy = 2
	AddressPortStrategy_SrvPortAndAddress AddressPortStrategy = 3
	AddressPortStrategy_TxtPortOnly       AddressPortStrategy = 4
	AddressPortStrategy_TxtAddressOnly    AddressPortStrategy = 5
	AddressPortStrategy_TxtPortAndAddress AddressPortStrategy = 6
)

// Enum value maps for AddressPortStrategy.
var (
	AddressPortStrategy_name = map[int32]string{
		0: "None",
		1: "SrvPortOnly",
		2: "SrvAddressOnly",
		3: "SrvPortAndAddress",
		4: "TxtPortOnly",
		5: "TxtAddressOnly",
		6: "TxtPortAndAddress",
	}
	AddressPortStrategy_value = map[string]int32{
		"None":              0,
		"SrvPortOnly":       1,
		"SrvAddressOnly":    2,
		"SrvPortAndAddress": 3,
		"TxtPortOnly":       4,
		"TxtAddressOnly":    5,
		"TxtPortAndAddress": 6,
	}
)

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

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

func (AddressPortStrategy) Descriptor() protoreflect.EnumDescriptor {
	return file_transport_internet_config_proto_enumTypes[1].Descriptor()
}

func (AddressPortStrategy) Type() protoreflect.EnumType {
	return &file_transport_internet_config_proto_enumTypes[1]
}

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

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

type SocketConfig_TProxyMode int32

const (
	// TProxy is off.
	SocketConfig_Off SocketConfig_TProxyMode = 0
	// TProxy mode.
	SocketConfig_TProxy SocketConfig_TProxyMode = 1
	// Redirect mode.
	SocketConfig_Redirect SocketConfig_TProxyMode = 2
)

// Enum value maps for SocketConfig_TProxyMode.
var (
	SocketConfig_TProxyMode_name = map[int32]string{
		0: "Off",
		1: "TProxy",
		2: "Redirect",
	}
	SocketConfig_TProxyMode_value = map[string]int32{
		"Off":      0,
		"TProxy":   1,
		"Redirect": 2,
	}
)

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

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

func (SocketConfig_TProxyMode) Descriptor() protoreflect.EnumDescriptor {
	return file_transport_internet_config_proto_enumTypes[2].Descriptor()
}

func (SocketConfig_TProxyMode) Type() protoreflect.EnumType {
	return &file_transport_internet_config_proto_enumTypes[2]
}

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

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

type TransportConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Transport protocol name.
	ProtocolName string `protobuf:"bytes,3,opt,name=protocol_name,json=protocolName,proto3" json:"protocol_name,omitempty"`
	// Specific transport protocol settings.
	Settings      *serial.TypedMessage `protobuf:"bytes,2,opt,name=settings,proto3" json:"settings,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TransportConfig) ProtoMessage() {}

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

func (x *TransportConfig) GetProtocolName() string {
	if x != nil {
		return x.ProtocolName
	}
	return ""
}

func (x *TransportConfig) GetSettings() *serial.TypedMessage {
	if x != nil {
		return x.Settings
	}
	return nil
}

type StreamConfig struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	Address *net.IPOrDomain        `protobuf:"bytes,8,opt,name=address,proto3" json:"address,omitempty"`
	Port    uint32                 `protobuf:"varint,9,opt,name=port,proto3" json:"port,omitempty"`
	// Effective network.
	ProtocolName      string             `protobuf:"bytes,5,opt,name=protocol_name,json=protocolName,proto3" json:"protocol_name,omitempty"`
	TransportSettings []*TransportConfig `protobuf:"bytes,2,rep,name=transport_settings,json=transportSettings,proto3" json:"transport_settings,omitempty"`
	// Type of security. Must be a message name of the settings proto.
	SecurityType string `protobuf:"bytes,3,opt,name=security_type,json=securityType,proto3" json:"security_type,omitempty"`
	// Transport security settings. They can be either TLS or REALITY.
	SecuritySettings []*serial.TypedMessage `protobuf:"bytes,4,rep,name=security_settings,json=securitySettings,proto3" json:"security_settings,omitempty"`
	Udpmasks         []*serial.TypedMessage `protobuf:"bytes,10,rep,name=udpmasks,proto3" json:"udpmasks,omitempty"`
	Tcpmasks         []*serial.TypedMessage `protobuf:"bytes,11,rep,name=tcpmasks,proto3" json:"tcpmasks,omitempty"`
	QuicParams       *QuicParams            `protobuf:"bytes,12,opt,name=quic_params,json=quicParams,proto3" json:"quic_params,omitempty"`
	SocketSettings   *SocketConfig          `protobuf:"bytes,6,opt,name=socket_settings,json=socketSettings,proto3" json:"socket_settings,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*StreamConfig) ProtoMessage() {}

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

func (x *StreamConfig) GetAddress() *net.IPOrDomain {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *StreamConfig) GetPort() uint32 {
	if x != nil {
		return x.Port
	}
	return 0
}

func (x *StreamConfig) GetProtocolName() string {
	if x != nil {
		return x.ProtocolName
	}
	return ""
}

func (x *StreamConfig) GetTransportSettings() []*TransportConfig {
	if x != nil {
		return x.TransportSettings
	}
	return nil
}

func (x *StreamConfig) GetSecurityType() string {
	if x != nil {
		return x.SecurityType
	}
	return ""
}

func (x *StreamConfig) GetSecuritySettings() []*serial.TypedMessage {
	if x != nil {
		return x.SecuritySettings
	}
	return nil
}

func (x *StreamConfig) GetUdpmasks() []*serial.TypedMessage {
	if x != nil {
		return x.Udpmasks
	}
	return nil
}

func (x *StreamConfig) GetTcpmasks() []*serial.TypedMessage {
	if x != nil {
		return x.Tcpmasks
	}
	return nil
}

func (x *StreamConfig) GetQuicParams() *QuicParams {
	if x != nil {
		return x.QuicParams
	}
	return nil
}

func (x *StreamConfig) GetSocketSettings() *SocketConfig {
	if x != nil {
		return x.SocketSettings
	}
	return nil
}

type UdpHop struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ports         []uint32               `protobuf:"varint,1,rep,packed,name=ports,proto3" json:"ports,omitempty"`
	IntervalMin   int64                  `protobuf:"varint,2,opt,name=interval_min,json=intervalMin,proto3" json:"interval_min,omitempty"`
	IntervalMax   int64                  `protobuf:"varint,3,opt,name=interval_max,json=intervalMax,proto3" json:"interval_max,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UdpHop) ProtoMessage() {}

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

func (x *UdpHop) GetPorts() []uint32 {
	if x != nil {
		return x.Ports
	}
	return nil
}

func (x *UdpHop) GetIntervalMin() int64 {
	if x != nil {
		return x.IntervalMin
	}
	return 0
}

func (x *UdpHop) GetIntervalMax() int64 {
	if x != nil {
		return x.IntervalMax
	}
	return 0
}

type QuicParams struct {
	state                   protoimpl.MessageState `protogen:"open.v1"`
	Congestion              string                 `protobuf:"bytes,1,opt,name=congestion,proto3" json:"congestion,omitempty"`
	BrutalUp                uint64                 `protobuf:"varint,2,opt,name=brutal_up,json=brutalUp,proto3" json:"brutal_up,omitempty"`
	BrutalDown              uint64                 `protobuf:"varint,3,opt,name=brutal_down,json=brutalDown,proto3" json:"brutal_down,omitempty"`
	UdpHop                  *UdpHop                `protobuf:"bytes,4,opt,name=udp_hop,json=udpHop,proto3" json:"udp_hop,omitempty"`
	InitStreamReceiveWindow uint64                 `protobuf:"varint,5,opt,name=init_stream_receive_window,json=initStreamReceiveWindow,proto3" json:"init_stream_receive_window,omitempty"`
	MaxStreamReceiveWindow  uint64                 `protobuf:"varint,6,opt,name=max_stream_receive_window,json=maxStreamReceiveWindow,proto3" json:"max_stream_receive_window,omitempty"`
	InitConnReceiveWindow   uint64                 `protobuf:"varint,7,opt,name=init_conn_receive_window,json=initConnReceiveWindow,proto3" json:"init_conn_receive_window,omitempty"`
	MaxConnReceiveWindow    uint64                 `protobuf:"varint,8,opt,name=max_conn_receive_window,json=maxConnReceiveWindow,proto3" json:"max_conn_receive_window,omitempty"`
	MaxIdleTimeout          int64                  `protobuf:"varint,9,opt,name=max_idle_timeout,json=maxIdleTimeout,proto3" json:"max_idle_timeout,omitempty"`
	KeepAlivePeriod         int64                  `protobuf:"varint,10,opt,name=keep_alive_period,json=keepAlivePeriod,proto3" json:"keep_alive_period,omitempty"`
	DisablePathMtuDiscovery bool                   `protobuf:"varint,11,opt,name=disable_path_mtu_discovery,json=disablePathMtuDiscovery,proto3" json:"disable_path_mtu_discovery,omitempty"`
	MaxIncomingStreams      int64                  `protobuf:"varint,12,opt,name=max_incoming_streams,json=maxIncomingStreams,proto3" json:"max_incoming_streams,omitempty"`
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

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

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

func (*QuicParams) ProtoMessage() {}

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

func (x *QuicParams) GetCongestion() string {
	if x != nil {
		return x.Congestion
	}
	return ""
}

func (x *QuicParams) GetBrutalUp() uint64 {
	if x != nil {
		return x.BrutalUp
	}
	return 0
}

func (x *QuicParams) GetBrutalDown() uint64 {
	if x != nil {
		return x.BrutalDown
	}
	return 0
}

func (x *QuicParams) GetUdpHop() *UdpHop {
	if x != nil {
		return x.UdpHop
	}
	return nil
}

func (x *QuicParams) GetInitStreamReceiveWindow() uint64 {
	if x != nil {
		return x.InitStreamReceiveWindow
	}
	return 0
}

func (x *QuicParams) GetMaxStreamReceiveWindow() uint64 {
	if x != nil {
		return x.MaxStreamReceiveWindow
	}
	return 0
}

func (x *QuicParams) GetInitConnReceiveWindow() uint64 {
	if x != nil {
		return x.InitConnReceiveWindow
	}
	return 0
}

func (x *QuicParams) GetMaxConnReceiveWindow() uint64 {
	if x != nil {
		return x.MaxConnReceiveWindow
	}
	return 0
}

func (x *QuicParams) GetMaxIdleTimeout() int64 {
	if x != nil {
		return x.MaxIdleTimeout
	}
	return 0
}

func (x *QuicParams) GetKeepAlivePeriod() int64 {
	if x != nil {
		return x.KeepAlivePeriod
	}
	return 0
}

func (x *QuicParams) GetDisablePathMtuDiscovery() bool {
	if x != nil {
		return x.DisablePathMtuDiscovery
	}
	return false
}

func (x *QuicParams) GetMaxIncomingStreams() int64 {
	if x != nil {
		return x.MaxIncomingStreams
	}
	return 0
}

type ProxyConfig struct {
	state               protoimpl.MessageState `protogen:"open.v1"`
	Tag                 string                 `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"`
	TransportLayerProxy bool                   `protobuf:"varint,2,opt,name=transportLayerProxy,proto3" json:"transportLayerProxy,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*ProxyConfig) ProtoMessage() {}

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

func (x *ProxyConfig) GetTag() string {
	if x != nil {
		return x.Tag
	}
	return ""
}

func (x *ProxyConfig) GetTransportLayerProxy() bool {
	if x != nil {
		return x.TransportLayerProxy
	}
	return false
}

type CustomSockopt struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	System        string                 `protobuf:"bytes,1,opt,name=system,proto3" json:"system,omitempty"`
	Network       string                 `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
	Level         string                 `protobuf:"bytes,3,opt,name=level,proto3" json:"level,omitempty"`
	Opt           string                 `protobuf:"bytes,4,opt,name=opt,proto3" json:"opt,omitempty"`
	Value         string                 `protobuf:"bytes,5,opt,name=value,proto3" json:"value,omitempty"`
	Type          string                 `protobuf:"bytes,6,opt,name=type,proto3" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CustomSockopt) ProtoMessage() {}

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

func (x *CustomSockopt) GetSystem() string {
	if x != nil {
		return x.System
	}
	return ""
}

func (x *CustomSockopt) GetNetwork() string {
	if x != nil {
		return x.Network
	}
	return ""
}

func (x *CustomSockopt) GetLevel() string {
	if x != nil {
		return x.Level
	}
	return ""
}

func (x *CustomSockopt) GetOpt() string {
	if x != nil {
		return x.Opt
	}
	return ""
}

func (x *CustomSockopt) GetValue() string {
	if x != nil {
		return x.Value
	}
	return ""
}

func (x *CustomSockopt) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

// SocketConfig is options to be applied on network sockets.
type SocketConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Mark of the connection. If non-zero, the value will be set to SO_MARK.
	Mark int32 `protobuf:"varint,1,opt,name=mark,proto3" json:"mark,omitempty"`
	// TFO is the state of TFO settings.
	Tfo int32 `protobuf:"varint,2,opt,name=tfo,proto3" json:"tfo,omitempty"`
	// TProxy is for enabling TProxy socket option.
	Tproxy SocketConfig_TProxyMode `protobuf:"varint,3,opt,name=tproxy,proto3,enum=xray.transport.internet.SocketConfig_TProxyMode" json:"tproxy,omitempty"`
	// ReceiveOriginalDestAddress is for enabling IP_RECVORIGDSTADDR socket
	// option. This option is for UDP only.
	ReceiveOriginalDestAddress bool                 `protobuf:"varint,4,opt,name=receive_original_dest_address,json=receiveOriginalDestAddress,proto3" json:"receive_original_dest_address,omitempty"`
	BindAddress                []byte               `protobuf:"bytes,5,opt,name=bind_address,json=bindAddress,proto3" json:"bind_address,omitempty"`
	BindPort                   uint32               `protobuf:"varint,6,opt,name=bind_port,json=bindPort,proto3" json:"bind_port,omitempty"`
	AcceptProxyProtocol        bool                 `protobuf:"varint,7,opt,name=accept_proxy_protocol,json=acceptProxyProtocol,proto3" json:"accept_proxy_protocol,omitempty"`
	DomainStrategy             DomainStrategy       `protobuf:"varint,8,opt,name=domain_strategy,json=domainStrategy,proto3,enum=xray.transport.internet.DomainStrategy" json:"domain_strategy,omitempty"`
	DialerProxy                string               `protobuf:"bytes,9,opt,name=dialer_proxy,json=dialerProxy,proto3" json:"dialer_proxy,omitempty"`
	TcpKeepAliveInterval       int32                `protobuf:"varint,10,opt,name=tcp_keep_alive_interval,json=tcpKeepAliveInterval,proto3" json:"tcp_keep_alive_interval,omitempty"`
	TcpKeepAliveIdle           int32                `protobuf:"varint,11,opt,name=tcp_keep_alive_idle,json=tcpKeepAliveIdle,proto3" json:"tcp_keep_alive_idle,omitempty"`
	TcpCongestion              string               `protobuf:"bytes,12,opt,name=tcp_congestion,json=tcpCongestion,proto3" json:"tcp_congestion,omitempty"`
	Interface                  string               `protobuf:"bytes,13,opt,name=interface,proto3" json:"interface,omitempty"`
	V6Only                     bool                 `protobuf:"varint,14,opt,name=v6only,proto3" json:"v6only,omitempty"`
	TcpWindowClamp             int32                `protobuf:"varint,15,opt,name=tcp_window_clamp,json=tcpWindowClamp,proto3" json:"tcp_window_clamp,omitempty"`
	TcpUserTimeout             int32                `protobuf:"varint,16,opt,name=tcp_user_timeout,json=tcpUserTimeout,proto3" json:"tcp_user_timeout,omitempty"`
	TcpMaxSeg                  int32                `protobuf:"varint,17,opt,name=tcp_max_seg,json=tcpMaxSeg,proto3" json:"tcp_max_seg,omitempty"`
	Penetrate                  bool                 `protobuf:"varint,18,opt,name=penetrate,proto3" json:"penetrate,omitempty"`
	TcpMptcp                   bool                 `protobuf:"varint,19,opt,name=tcp_mptcp,json=tcpMptcp,proto3" json:"tcp_mptcp,omitempty"`
	CustomSockopt              []*CustomSockopt     `protobuf:"bytes,20,rep,name=customSockopt,proto3" json:"customSockopt,omitempty"`
	AddressPortStrategy        AddressPortStrategy  `protobuf:"varint,21,opt,name=address_port_strategy,json=addressPortStrategy,proto3,enum=xray.transport.internet.AddressPortStrategy" json:"address_port_strategy,omitempty"`
	HappyEyeballs              *HappyEyeballsConfig `protobuf:"bytes,22,opt,name=happy_eyeballs,json=happyEyeballs,proto3" json:"happy_eyeballs,omitempty"`
	TrustedXForwardedFor       []string             `protobuf:"bytes,23,rep,name=trusted_x_forwarded_for,json=trustedXForwardedFor,proto3" json:"trusted_x_forwarded_for,omitempty"`
	unknownFields              protoimpl.UnknownFields
	sizeCache                  protoimpl.SizeCache
}

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

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

func (*SocketConfig) ProtoMessage() {}

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

func (x *SocketConfig) GetMark() int32 {
	if x != nil {
		return x.Mark
	}
	return 0
}

func (x *SocketConfig) GetTfo() int32 {
	if x != nil {
		return x.Tfo
	}
	return 0
}

func (x *SocketConfig) GetTproxy() SocketConfig_TProxyMode {
	if x != nil {
		return x.Tproxy
	}
	return SocketConfig_Off
}

func (x *SocketConfig) GetReceiveOriginalDestAddress() bool {
	if x != nil {
		return x.ReceiveOriginalDestAddress
	}
	return false
}

func (x *SocketConfig) GetBindAddress() []byte {
	if x != nil {
		return x.BindAddress
	}
	return nil
}

func (x *SocketConfig) GetBindPort() uint32 {
	if x != nil {
		return x.BindPort
	}
	return 0
}

func (x *SocketConfig) GetAcceptProxyProtocol() bool {
	if x != nil {
		return x.AcceptProxyProtocol
	}
	return false
}

func (x *SocketConfig) GetDomainStrategy() DomainStrategy {
	if x != nil {
		return x.DomainStrategy
	}
	return DomainStrategy_AS_IS
}

func (x *SocketConfig) GetDialerProxy() string {
	if x != nil {
		return x.DialerProxy
	}
	return ""
}

func (x *SocketConfig) GetTcpKeepAliveInterval() int32 {
	if x != nil {
		return x.TcpKeepAliveInterval
	}
	return 0
}

func (x *SocketConfig) GetTcpKeepAliveIdle() int32 {
	if x != nil {
		return x.TcpKeepAliveIdle
	}
	return 0
}

func (x *SocketConfig) GetTcpCongestion() string {
	if x != nil {
		return x.TcpCongestion
	}
	return ""
}

func (x *SocketConfig) GetInterface() string {
	if x != nil {
		return x.Interface
	}
	return ""
}

func (x *SocketConfig) GetV6Only() bool {
	if x != nil {
		return x.V6Only
	}
	return false
}

func (x *SocketConfig) GetTcpWindowClamp() int32 {
	if x != nil {
		return x.TcpWindowClamp
	}
	return 0
}

func (x *SocketConfig) GetTcpUserTimeout() int32 {
	if x != nil {
		return x.TcpUserTimeout
	}
	return 0
}

func (x *SocketConfig) GetTcpMaxSeg() int32 {
	if x != nil {
		return x.TcpMaxSeg
	}
	return 0
}

func (x *SocketConfig) GetPenetrate() bool {
	if x != nil {
		return x.Penetrate
	}
	return false
}

func (x *SocketConfig) GetTcpMptcp() bool {
	if x != nil {
		return x.TcpMptcp
	}
	return false
}

func (x *SocketConfig) GetCustomSockopt() []*CustomSockopt {
	if x != nil {
		return x.CustomSockopt
	}
	return nil
}

func (x *SocketConfig) GetAddressPortStrategy() AddressPortStrategy {
	if x != nil {
		return x.AddressPortStrategy
	}
	return AddressPortStrategy_None
}

func (x *SocketConfig) GetHappyEyeballs() *HappyEyeballsConfig {
	if x != nil {
		return x.HappyEyeballs
	}
	return nil
}

func (x *SocketConfig) GetTrustedXForwardedFor() []string {
	if x != nil {
		return x.TrustedXForwardedFor
	}
	return nil
}

type HappyEyeballsConfig struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	PrioritizeIpv6   bool                   `protobuf:"varint,1,opt,name=prioritize_ipv6,json=prioritizeIpv6,proto3" json:"prioritize_ipv6,omitempty"`
	Interleave       uint32                 `protobuf:"varint,2,opt,name=interleave,proto3" json:"interleave,omitempty"`
	TryDelayMs       uint64                 `protobuf:"varint,3,opt,name=try_delayMs,json=tryDelayMs,proto3" json:"try_delayMs,omitempty"`
	MaxConcurrentTry uint32                 `protobuf:"varint,4,opt,name=max_concurrent_try,json=maxConcurrentTry,proto3" json:"max_concurrent_try,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*HappyEyeballsConfig) ProtoMessage() {}

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

func (x *HappyEyeballsConfig) GetPrioritizeIpv6() bool {
	if x != nil {
		return x.PrioritizeIpv6
	}
	return false
}

func (x *HappyEyeballsConfig) GetInterleave() uint32 {
	if x != nil {
		return x.Interleave
	}
	return 0
}

func (x *HappyEyeballsConfig) GetTryDelayMs() uint64 {
	if x != nil {
		return x.TryDelayMs
	}
	return 0
}

func (x *HappyEyeballsConfig) GetMaxConcurrentTry() uint32 {
	if x != nil {
		return x.MaxConcurrentTry
	}
	return 0
}

var File_transport_internet_config_proto protoreflect.FileDescriptor

const file_transport_internet_config_proto_rawDesc = "" +
	"\n" +
	"\x1ftransport/internet/config.proto\x12\x17xray.transport.internet\x1a!common/serial/typed_message.proto\x1a\x18common/net/address.proto\"t\n" +
	"\x0fTransportConfig\x12#\n" +
	"\rprotocol_name\x18\x03 \x01(\tR\fprotocolName\x12<\n" +
	"\bsettings\x18\x02 \x01(\v2 .xray.common.serial.TypedMessageR\bsettings\"\xdd\x04\n" +
	"\fStreamConfig\x125\n" +
	"\aaddress\x18\b \x01(\v2\x1b.xray.common.net.IPOrDomainR\aaddress\x12\x12\n" +
	"\x04port\x18\t \x01(\rR\x04port\x12#\n" +
	"\rprotocol_name\x18\x05 \x01(\tR\fprotocolName\x12W\n" +
	"\x12transport_settings\x18\x02 \x03(\v2(.xray.transport.internet.TransportConfigR\x11transportSettings\x12#\n" +
	"\rsecurity_type\x18\x03 \x01(\tR\fsecurityType\x12M\n" +
	"\x11security_settings\x18\x04 \x03(\v2 .xray.common.serial.TypedMessageR\x10securitySettings\x12<\n" +
	"\budpmasks\x18\n" +
	" \x03(\v2 .xray.common.serial.TypedMessageR\budpmasks\x12<\n" +
	"\btcpmasks\x18\v \x03(\v2 .xray.common.serial.TypedMessageR\btcpmasks\x12D\n" +
	"\vquic_params\x18\f \x01(\v2#.xray.transport.internet.QuicParamsR\n" +
	"quicParams\x12N\n" +
	"\x0fsocket_settings\x18\x06 \x01(\v2%.xray.transport.internet.SocketConfigR\x0esocketSettings\"d\n" +
	"\x06UdpHop\x12\x14\n" +
	"\x05ports\x18\x01 \x03(\rR\x05ports\x12!\n" +
	"\finterval_min\x18\x02 \x01(\x03R\vintervalMin\x12!\n" +
	"\finterval_max\x18\x03 \x01(\x03R\vintervalMax\"\xd1\x04\n" +
	"\n" +
	"QuicParams\x12\x1e\n" +
	"\n" +
	"congestion\x18\x01 \x01(\tR\n" +
	"congestion\x12\x1b\n" +
	"\tbrutal_up\x18\x02 \x01(\x04R\bbrutalUp\x12\x1f\n" +
	"\vbrutal_down\x18\x03 \x01(\x04R\n" +
	"brutalDown\x128\n" +
	"\audp_hop\x18\x04 \x01(\v2\x1f.xray.transport.internet.UdpHopR\x06udpHop\x12;\n" +
	"\x1ainit_stream_receive_window\x18\x05 \x01(\x04R\x17initStreamReceiveWindow\x129\n" +
	"\x19max_stream_receive_window\x18\x06 \x01(\x04R\x16maxStreamReceiveWindow\x127\n" +
	"\x18init_conn_receive_window\x18\a \x01(\x04R\x15initConnReceiveWindow\x125\n" +
	"\x17max_conn_receive_window\x18\b \x01(\x04R\x14maxConnReceiveWindow\x12(\n" +
	"\x10max_idle_timeout\x18\t \x01(\x03R\x0emaxIdleTimeout\x12*\n" +
	"\x11keep_alive_period\x18\n" +
	" \x01(\x03R\x0fkeepAlivePeriod\x12;\n" +
	"\x1adisable_path_mtu_discovery\x18\v \x01(\bR\x17disablePathMtuDiscovery\x120\n" +
	"\x14max_incoming_streams\x18\f \x01(\x03R\x12maxIncomingStreams\"Q\n" +
	"\vProxyConfig\x12\x10\n" +
	"\x03tag\x18\x01 \x01(\tR\x03tag\x120\n" +
	"\x13transportLayerProxy\x18\x02 \x01(\bR\x13transportLayerProxy\"\x93\x01\n" +
	"\rCustomSockopt\x12\x16\n" +
	"\x06system\x18\x01 \x01(\tR\x06system\x12\x18\n" +
	"\anetwork\x18\x02 \x01(\tR\anetwork\x12\x14\n" +
	"\x05level\x18\x03 \x01(\tR\x05level\x12\x10\n" +
	"\x03opt\x18\x04 \x01(\tR\x03opt\x12\x14\n" +
	"\x05value\x18\x05 \x01(\tR\x05value\x12\x12\n" +
	"\x04type\x18\x06 \x01(\tR\x04type\"\x89\t\n" +
	"\fSocketConfig\x12\x12\n" +
	"\x04mark\x18\x01 \x01(\x05R\x04mark\x12\x10\n" +
	"\x03tfo\x18\x02 \x01(\x05R\x03tfo\x12H\n" +
	"\x06tproxy\x18\x03 \x01(\x0e20.xray.transport.internet.SocketConfig.TProxyModeR\x06tproxy\x12A\n" +
	"\x1dreceive_original_dest_address\x18\x04 \x01(\bR\x1areceiveOriginalDestAddress\x12!\n" +
	"\fbind_address\x18\x05 \x01(\fR\vbindAddress\x12\x1b\n" +
	"\tbind_port\x18\x06 \x01(\rR\bbindPort\x122\n" +
	"\x15accept_proxy_protocol\x18\a \x01(\bR\x13acceptProxyProtocol\x12P\n" +
	"\x0fdomain_strategy\x18\b \x01(\x0e2'.xray.transport.internet.DomainStrategyR\x0edomainStrategy\x12!\n" +
	"\fdialer_proxy\x18\t \x01(\tR\vdialerProxy\x125\n" +
	"\x17tcp_keep_alive_interval\x18\n" +
	" \x01(\x05R\x14tcpKeepAliveInterval\x12-\n" +
	"\x13tcp_keep_alive_idle\x18\v \x01(\x05R\x10tcpKeepAliveIdle\x12%\n" +
	"\x0etcp_congestion\x18\f \x01(\tR\rtcpCongestion\x12\x1c\n" +
	"\tinterface\x18\r \x01(\tR\tinterface\x12\x16\n" +
	"\x06v6only\x18\x0e \x01(\bR\x06v6only\x12(\n" +
	"\x10tcp_window_clamp\x18\x0f \x01(\x05R\x0etcpWindowClamp\x12(\n" +
	"\x10tcp_user_timeout\x18\x10 \x01(\x05R\x0etcpUserTimeout\x12\x1e\n" +
	"\vtcp_max_seg\x18\x11 \x01(\x05R\ttcpMaxSeg\x12\x1c\n" +
	"\tpenetrate\x18\x12 \x01(\bR\tpenetrate\x12\x1b\n" +
	"\ttcp_mptcp\x18\x13 \x01(\bR\btcpMptcp\x12L\n" +
	"\rcustomSockopt\x18\x14 \x03(\v2&.xray.transport.internet.CustomSockoptR\rcustomSockopt\x12`\n" +
	"\x15address_port_strategy\x18\x15 \x01(\x0e2,.xray.transport.internet.AddressPortStrategyR\x13addressPortStrategy\x12S\n" +
	"\x0ehappy_eyeballs\x18\x16 \x01(\v2,.xray.transport.internet.HappyEyeballsConfigR\rhappyEyeballs\x125\n" +
	"\x17trusted_x_forwarded_for\x18\x17 \x03(\tR\x14trustedXForwardedFor\"/\n" +
	"\n" +
	"TProxyMode\x12\a\n" +
	"\x03Off\x10\x00\x12\n" +
	"\n" +
	"\x06TProxy\x10\x01\x12\f\n" +
	"\bRedirect\x10\x02\"\xad\x01\n" +
	"\x13HappyEyeballsConfig\x12'\n" +
	"\x0fprioritize_ipv6\x18\x01 \x01(\bR\x0eprioritizeIpv6\x12\x1e\n" +
	"\n" +
	"interleave\x18\x02 \x01(\rR\n" +
	"interleave\x12\x1f\n" +
	"\vtry_delayMs\x18\x03 \x01(\x04R\n" +
	"tryDelayMs\x12,\n" +
	"\x12max_concurrent_try\x18\x04 \x01(\rR\x10maxConcurrentTry*\xa9\x01\n" +
	"\x0eDomainStrategy\x12\t\n" +
	"\x05AS_IS\x10\x00\x12\n" +
	"\n" +
	"\x06USE_IP\x10\x01\x12\v\n" +
	"\aUSE_IP4\x10\x02\x12\v\n" +
	"\aUSE_IP6\x10\x03\x12\f\n" +
	"\bUSE_IP46\x10\x04\x12\f\n" +
	"\bUSE_IP64\x10\x05\x12\f\n" +
	"\bFORCE_IP\x10\x06\x12\r\n" +
	"\tFORCE_IP4\x10\a\x12\r\n" +
	"\tFORCE_IP6\x10\b\x12\x0e\n" +
	"\n" +
	"FORCE_IP46\x10\t\x12\x0e\n" +
	"\n" +
	"FORCE_IP64\x10\n" +
	"*\x97\x01\n" +
	"\x13AddressPortStrategy\x12\b\n" +
	"\x04None\x10\x00\x12\x0f\n" +
	"\vSrvPortOnly\x10\x01\x12\x12\n" +
	"\x0eSrvAddressOnly\x10\x02\x12\x15\n" +
	"\x11SrvPortAndAddress\x10\x03\x12\x0f\n" +
	"\vTxtPortOnly\x10\x04\x12\x12\n" +
	"\x0eTxtAddressOnly\x10\x05\x12\x15\n" +
	"\x11TxtPortAndAddress\x10\x06Bg\n" +
	"\x1bcom.xray.transport.internetP\x01Z,github.com/xtls/xray-core/transport/internet\xaa\x02\x17Xray.Transport.Internetb\x06proto3"

var (
	file_transport_internet_config_proto_rawDescOnce sync.Once
	file_transport_internet_config_proto_rawDescData []byte
)

func file_transport_internet_config_proto_rawDescGZIP() []byte {
	file_transport_internet_config_proto_rawDescOnce.Do(func() {
		file_transport_internet_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_config_proto_rawDesc), len(file_transport_internet_config_proto_rawDesc)))
	})
	return file_transport_internet_config_proto_rawDescData
}

var file_transport_internet_config_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_transport_internet_config_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
var file_transport_internet_config_proto_goTypes = []any{
	(DomainStrategy)(0),          // 0: xray.transport.internet.DomainStrategy
	(AddressPortStrategy)(0),     // 1: xray.transport.internet.AddressPortStrategy
	(SocketConfig_TProxyMode)(0), // 2: xray.transport.internet.SocketConfig.TProxyMode
	(*TransportConfig)(nil),      // 3: xray.transport.internet.TransportConfig
	(*StreamConfig)(nil),         // 4: xray.transport.internet.StreamConfig
	(*UdpHop)(nil),               // 5: xray.transport.internet.UdpHop
	(*QuicParams)(nil),           // 6: xray.transport.internet.QuicParams
	(*ProxyConfig)(nil),          // 7: xray.transport.internet.ProxyConfig
	(*CustomSockopt)(nil),        // 8: xray.transport.internet.CustomSockopt
	(*SocketConfig)(nil),         // 9: xray.transport.internet.SocketConfig
	(*HappyEyeballsConfig)(nil),  // 10: xray.transport.internet.HappyEyeballsConfig
	(*serial.TypedMessage)(nil),  // 11: xray.common.serial.TypedMessage
	(*net.IPOrDomain)(nil),       // 12: xray.common.net.IPOrDomain
}
var file_transport_internet_config_proto_depIdxs = []int32{
	11, // 0: xray.transport.internet.TransportConfig.settings:type_name -> xray.common.serial.TypedMessage
	12, // 1: xray.transport.internet.StreamConfig.address:type_name -> xray.common.net.IPOrDomain
	3,  // 2: xray.transport.internet.StreamConfig.transport_settings:type_name -> xray.transport.internet.TransportConfig
	11, // 3: xray.transport.internet.StreamConfig.security_settings:type_name -> xray.common.serial.TypedMessage
	11, // 4: xray.transport.internet.StreamConfig.udpmasks:type_name -> xray.common.serial.TypedMessage
	11, // 5: xray.transport.internet.StreamConfig.tcpmasks:type_name -> xray.common.serial.TypedMessage
	6,  // 6: xray.transport.internet.StreamConfig.quic_params:type_name -> xray.transport.internet.QuicParams
	9,  // 7: xray.transport.internet.StreamConfig.socket_settings:type_name -> xray.transport.internet.SocketConfig
	5,  // 8: xray.transport.internet.QuicParams.udp_hop:type_name -> xray.transport.internet.UdpHop
	2,  // 9: xray.transport.internet.SocketConfig.tproxy:type_name -> xray.transport.internet.SocketConfig.TProxyMode
	0,  // 10: xray.transport.internet.SocketConfig.domain_strategy:type_name -> xray.transport.internet.DomainStrategy
	8,  // 11: xray.transport.internet.SocketConfig.customSockopt:type_name -> xray.transport.internet.CustomSockopt
	1,  // 12: xray.transport.internet.SocketConfig.address_port_strategy:type_name -> xray.transport.internet.AddressPortStrategy
	10, // 13: xray.transport.internet.SocketConfig.happy_eyeballs:type_name -> xray.transport.internet.HappyEyeballsConfig
	14, // [14:14] is the sub-list for method output_type
	14, // [14:14] is the sub-list for method input_type
	14, // [14:14] is the sub-list for extension type_name
	14, // [14:14] is the sub-list for extension extendee
	0,  // [0:14] is the sub-list for field type_name
}

func init() { file_transport_internet_config_proto_init() }
func file_transport_internet_config_proto_init() {
	if File_transport_internet_config_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_config_proto_rawDesc), len(file_transport_internet_config_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   8,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_transport_internet_config_proto_goTypes,
		DependencyIndexes: file_transport_internet_config_proto_depIdxs,
		EnumInfos:         file_transport_internet_config_proto_enumTypes,
		MessageInfos:      file_transport_internet_config_proto_msgTypes,
	}.Build()
	File_transport_internet_config_proto = out.File
	file_transport_internet_config_proto_goTypes = nil
	file_transport_internet_config_proto_depIdxs = nil
}