// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.35.1
// source: common.proto

package common

import (
	error1 "github.com/easytier/easytier/easytier-go/proto/error"
	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 CompressionAlgoPb int32

const (
	CompressionAlgoPb_Invalid CompressionAlgoPb = 0
	CompressionAlgoPb_None    CompressionAlgoPb = 1
	CompressionAlgoPb_Zstd    CompressionAlgoPb = 2
)

// Enum value maps for CompressionAlgoPb.
var (
	CompressionAlgoPb_name = map[int32]string{
		0: "Invalid",
		1: "None",
		2: "Zstd",
	}
	CompressionAlgoPb_value = map[string]int32{
		"Invalid": 0,
		"None":    1,
		"Zstd":    2,
	}
)

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

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

func (CompressionAlgoPb) Descriptor() protoreflect.EnumDescriptor {
	return file_common_proto_enumTypes[0].Descriptor()
}

func (CompressionAlgoPb) Type() protoreflect.EnumType {
	return &file_common_proto_enumTypes[0]
}

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

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

type NatType int32

const (
	// has NAT; but own a single public IP, port is not changed
	NatType_Unknown          NatType = 0
	NatType_OpenInternet     NatType = 1
	NatType_NoPAT            NatType = 2
	NatType_FullCone         NatType = 3
	NatType_Restricted       NatType = 4
	NatType_PortRestricted   NatType = 5
	NatType_Symmetric        NatType = 6
	NatType_SymUdpFirewall   NatType = 7
	NatType_SymmetricEasyInc NatType = 8
	NatType_SymmetricEasyDec NatType = 9
)

// Enum value maps for NatType.
var (
	NatType_name = map[int32]string{
		0: "Unknown",
		1: "OpenInternet",
		2: "NoPAT",
		3: "FullCone",
		4: "Restricted",
		5: "PortRestricted",
		6: "Symmetric",
		7: "SymUdpFirewall",
		8: "SymmetricEasyInc",
		9: "SymmetricEasyDec",
	}
	NatType_value = map[string]int32{
		"Unknown":          0,
		"OpenInternet":     1,
		"NoPAT":            2,
		"FullCone":         3,
		"Restricted":       4,
		"PortRestricted":   5,
		"Symmetric":        6,
		"SymUdpFirewall":   7,
		"SymmetricEasyInc": 8,
		"SymmetricEasyDec": 9,
	}
)

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

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

func (NatType) Descriptor() protoreflect.EnumDescriptor {
	return file_common_proto_enumTypes[1].Descriptor()
}

func (NatType) Type() protoreflect.EnumType {
	return &file_common_proto_enumTypes[1]
}

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

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

type SocketType int32

const (
	SocketType_TCP SocketType = 0
	SocketType_UDP SocketType = 1
)

// Enum value maps for SocketType.
var (
	SocketType_name = map[int32]string{
		0: "TCP",
		1: "UDP",
	}
	SocketType_value = map[string]int32{
		"TCP": 0,
		"UDP": 1,
	}
)

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

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

func (SocketType) Descriptor() protoreflect.EnumDescriptor {
	return file_common_proto_enumTypes[2].Descriptor()
}

func (SocketType) Type() protoreflect.EnumType {
	return &file_common_proto_enumTypes[2]
}

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

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

type FlagsInConfig struct {
	state                  protoimpl.MessageState `protogen:"open.v1"`
	DefaultProtocol        string                 `protobuf:"bytes,1,opt,name=default_protocol,json=defaultProtocol,proto3" json:"default_protocol,omitempty"`
	DevName                string                 `protobuf:"bytes,2,opt,name=dev_name,json=devName,proto3" json:"dev_name,omitempty"`
	EnableEncryption       bool                   `protobuf:"varint,3,opt,name=enable_encryption,json=enableEncryption,proto3" json:"enable_encryption,omitempty"`
	EnableIpv6             bool                   `protobuf:"varint,4,opt,name=enable_ipv6,json=enableIpv6,proto3" json:"enable_ipv6,omitempty"`
	Mtu                    uint32                 `protobuf:"varint,5,opt,name=mtu,proto3" json:"mtu,omitempty"`
	LatencyFirst           bool                   `protobuf:"varint,6,opt,name=latency_first,json=latencyFirst,proto3" json:"latency_first,omitempty"`
	EnableExitNode         bool                   `protobuf:"varint,7,opt,name=enable_exit_node,json=enableExitNode,proto3" json:"enable_exit_node,omitempty"`
	NoTun                  bool                   `protobuf:"varint,8,opt,name=no_tun,json=noTun,proto3" json:"no_tun,omitempty"`
	UseSmoltcp             bool                   `protobuf:"varint,9,opt,name=use_smoltcp,json=useSmoltcp,proto3" json:"use_smoltcp,omitempty"`
	RelayNetworkWhitelist  string                 `protobuf:"bytes,10,opt,name=relay_network_whitelist,json=relayNetworkWhitelist,proto3" json:"relay_network_whitelist,omitempty"`
	DisableP2P             bool                   `protobuf:"varint,11,opt,name=disable_p2p,json=disableP2p,proto3" json:"disable_p2p,omitempty"`
	RelayAllPeerRpc        bool                   `protobuf:"varint,12,opt,name=relay_all_peer_rpc,json=relayAllPeerRpc,proto3" json:"relay_all_peer_rpc,omitempty"`
	DisableUdpHolePunching bool                   `protobuf:"varint,13,opt,name=disable_udp_hole_punching,json=disableUdpHolePunching,proto3" json:"disable_udp_hole_punching,omitempty"`
	// string ipv6_listener = 14; [deprecated = true]; use -l udp://[::]:12345
	// instead
	MultiThread      bool              `protobuf:"varint,15,opt,name=multi_thread,json=multiThread,proto3" json:"multi_thread,omitempty"`
	DataCompressAlgo CompressionAlgoPb `protobuf:"varint,16,opt,name=data_compress_algo,json=dataCompressAlgo,proto3,enum=common.CompressionAlgoPb" json:"data_compress_algo,omitempty"`
	BindDevice       bool              `protobuf:"varint,17,opt,name=bind_device,json=bindDevice,proto3" json:"bind_device,omitempty"`
	// should we convert all tcp streams into kcp streams
	EnableKcpProxy bool `protobuf:"varint,18,opt,name=enable_kcp_proxy,json=enableKcpProxy,proto3" json:"enable_kcp_proxy,omitempty"`
	// does this peer allow kcp input
	DisableKcpInput bool `protobuf:"varint,19,opt,name=disable_kcp_input,json=disableKcpInput,proto3" json:"disable_kcp_input,omitempty"`
	// disable relay local network kcp packets
	DisableRelayKcp      bool `protobuf:"varint,20,opt,name=disable_relay_kcp,json=disableRelayKcp,proto3" json:"disable_relay_kcp,omitempty"`
	ProxyForwardBySystem bool `protobuf:"varint,21,opt,name=proxy_forward_by_system,json=proxyForwardBySystem,proto3" json:"proxy_forward_by_system,omitempty"`
	// enable magic dns or not
	AcceptDns bool `protobuf:"varint,22,opt,name=accept_dns,json=acceptDns,proto3" json:"accept_dns,omitempty"`
	// enable private mode
	PrivateMode bool `protobuf:"varint,23,opt,name=private_mode,json=privateMode,proto3" json:"private_mode,omitempty"`
	// should we convert all tcp streams into quic streams
	EnableQuicProxy bool `protobuf:"varint,24,opt,name=enable_quic_proxy,json=enableQuicProxy,proto3" json:"enable_quic_proxy,omitempty"`
	// does this peer allow quic input
	DisableQuicInput bool `protobuf:"varint,25,opt,name=disable_quic_input,json=disableQuicInput,proto3" json:"disable_quic_input,omitempty"`
	// disable relay local network quic packets
	DisableRelayQuic bool `protobuf:"varint,35,opt,name=disable_relay_quic,json=disableRelayQuic,proto3" json:"disable_relay_quic,omitempty"`
	// quic listen port
	//
	// Deprecated: Marked as deprecated in common.proto.
	QuicListenPort uint32 `protobuf:"varint,33,opt,name=quic_listen_port,json=quicListenPort,proto3" json:"quic_listen_port,omitempty"`
	// a global relay limit, only work for foreign network
	ForeignRelayBpsLimit uint64 `protobuf:"varint,26,opt,name=foreign_relay_bps_limit,json=foreignRelayBpsLimit,proto3" json:"foreign_relay_bps_limit,omitempty"`
	MultiThreadCount     uint32 `protobuf:"varint,27,opt,name=multi_thread_count,json=multiThreadCount,proto3" json:"multi_thread_count,omitempty"`
	// enable relay foreign network kcp packets
	EnableRelayForeignNetworkKcp bool `protobuf:"varint,28,opt,name=enable_relay_foreign_network_kcp,json=enableRelayForeignNetworkKcp,proto3" json:"enable_relay_foreign_network_kcp,omitempty"`
	// enable relay foreign network quic packets
	EnableRelayForeignNetworkQuic bool `protobuf:"varint,36,opt,name=enable_relay_foreign_network_quic,json=enableRelayForeignNetworkQuic,proto3" json:"enable_relay_foreign_network_quic,omitempty"`
	// encryption algorithm to use, empty string means default (aes-gcm)
	EncryptionAlgorithm string `protobuf:"bytes,29,opt,name=encryption_algorithm,json=encryptionAlgorithm,proto3" json:"encryption_algorithm,omitempty"`
	// disable symmetric nat hole punching, treat symmetric as cone when enabled
	DisableSymHolePunching bool `protobuf:"varint,30,opt,name=disable_sym_hole_punching,json=disableSymHolePunching,proto3" json:"disable_sym_hole_punching,omitempty"`
	// tld dns zone for magic dns
	TldDnsZone              string `protobuf:"bytes,31,opt,name=tld_dns_zone,json=tldDnsZone,proto3" json:"tld_dns_zone,omitempty"`
	P2POnly                 bool   `protobuf:"varint,32,opt,name=p2p_only,json=p2pOnly,proto3" json:"p2p_only,omitempty"`
	DisableTcpHolePunching  bool   `protobuf:"varint,34,opt,name=disable_tcp_hole_punching,json=disableTcpHolePunching,proto3" json:"disable_tcp_hole_punching,omitempty"`
	LazyP2P                 bool   `protobuf:"varint,37,opt,name=lazy_p2p,json=lazyP2p,proto3" json:"lazy_p2p,omitempty"`
	NeedP2P                 bool   `protobuf:"varint,38,opt,name=need_p2p,json=needP2p,proto3" json:"need_p2p,omitempty"`
	InstanceRecvBpsLimit    uint64 `protobuf:"varint,39,opt,name=instance_recv_bps_limit,json=instanceRecvBpsLimit,proto3" json:"instance_recv_bps_limit,omitempty"`
	DisableUpnp             bool   `protobuf:"varint,40,opt,name=disable_upnp,json=disableUpnp,proto3" json:"disable_upnp,omitempty"`
	DisableRelayData        bool   `protobuf:"varint,41,opt,name=disable_relay_data,json=disableRelayData,proto3" json:"disable_relay_data,omitempty"`
	EnableUdpBroadcastRelay bool   `protobuf:"varint,42,opt,name=enable_udp_broadcast_relay,json=enableUdpBroadcastRelay,proto3" json:"enable_udp_broadcast_relay,omitempty"`
	// Linux-only: SO_MARK (fwmark) value applied to every outbound underlay
	// socket (TCP/UDP/QUIC/WS/WG connectors and listeners). Unset = leave
	// SO_MARK untouched (kernel default 0). Any set value (including 0) is
	// applied via setsockopt. Requires CAP_NET_ADMIN; silently ignored on
	// non-Linux platforms.
	SocketMark *uint32 `protobuf:"varint,43,opt,name=socket_mark,json=socketMark,proto3,oneof" json:"socket_mark,omitempty"`
	// Prefer direct credential peers that already relay to a destination over
	// advertising another direct edge to the same destination.
	PreferPeerRelay bool `protobuf:"varint,44,opt,name=prefer_peer_relay,json=preferPeerRelay,proto3" json:"prefer_peer_relay,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*FlagsInConfig) ProtoMessage() {}

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

func (x *FlagsInConfig) GetDefaultProtocol() string {
	if x != nil {
		return x.DefaultProtocol
	}
	return ""
}

func (x *FlagsInConfig) GetDevName() string {
	if x != nil {
		return x.DevName
	}
	return ""
}

func (x *FlagsInConfig) GetEnableEncryption() bool {
	if x != nil {
		return x.EnableEncryption
	}
	return false
}

func (x *FlagsInConfig) GetEnableIpv6() bool {
	if x != nil {
		return x.EnableIpv6
	}
	return false
}

func (x *FlagsInConfig) GetMtu() uint32 {
	if x != nil {
		return x.Mtu
	}
	return 0
}

func (x *FlagsInConfig) GetLatencyFirst() bool {
	if x != nil {
		return x.LatencyFirst
	}
	return false
}

func (x *FlagsInConfig) GetEnableExitNode() bool {
	if x != nil {
		return x.EnableExitNode
	}
	return false
}

func (x *FlagsInConfig) GetNoTun() bool {
	if x != nil {
		return x.NoTun
	}
	return false
}

func (x *FlagsInConfig) GetUseSmoltcp() bool {
	if x != nil {
		return x.UseSmoltcp
	}
	return false
}

func (x *FlagsInConfig) GetRelayNetworkWhitelist() string {
	if x != nil {
		return x.RelayNetworkWhitelist
	}
	return ""
}

func (x *FlagsInConfig) GetDisableP2P() bool {
	if x != nil {
		return x.DisableP2P
	}
	return false
}

func (x *FlagsInConfig) GetRelayAllPeerRpc() bool {
	if x != nil {
		return x.RelayAllPeerRpc
	}
	return false
}

func (x *FlagsInConfig) GetDisableUdpHolePunching() bool {
	if x != nil {
		return x.DisableUdpHolePunching
	}
	return false
}

func (x *FlagsInConfig) GetMultiThread() bool {
	if x != nil {
		return x.MultiThread
	}
	return false
}

func (x *FlagsInConfig) GetDataCompressAlgo() CompressionAlgoPb {
	if x != nil {
		return x.DataCompressAlgo
	}
	return CompressionAlgoPb_Invalid
}

func (x *FlagsInConfig) GetBindDevice() bool {
	if x != nil {
		return x.BindDevice
	}
	return false
}

func (x *FlagsInConfig) GetEnableKcpProxy() bool {
	if x != nil {
		return x.EnableKcpProxy
	}
	return false
}

func (x *FlagsInConfig) GetDisableKcpInput() bool {
	if x != nil {
		return x.DisableKcpInput
	}
	return false
}

func (x *FlagsInConfig) GetDisableRelayKcp() bool {
	if x != nil {
		return x.DisableRelayKcp
	}
	return false
}

func (x *FlagsInConfig) GetProxyForwardBySystem() bool {
	if x != nil {
		return x.ProxyForwardBySystem
	}
	return false
}

func (x *FlagsInConfig) GetAcceptDns() bool {
	if x != nil {
		return x.AcceptDns
	}
	return false
}

func (x *FlagsInConfig) GetPrivateMode() bool {
	if x != nil {
		return x.PrivateMode
	}
	return false
}

func (x *FlagsInConfig) GetEnableQuicProxy() bool {
	if x != nil {
		return x.EnableQuicProxy
	}
	return false
}

func (x *FlagsInConfig) GetDisableQuicInput() bool {
	if x != nil {
		return x.DisableQuicInput
	}
	return false
}

func (x *FlagsInConfig) GetDisableRelayQuic() bool {
	if x != nil {
		return x.DisableRelayQuic
	}
	return false
}

// Deprecated: Marked as deprecated in common.proto.
func (x *FlagsInConfig) GetQuicListenPort() uint32 {
	if x != nil {
		return x.QuicListenPort
	}
	return 0
}

func (x *FlagsInConfig) GetForeignRelayBpsLimit() uint64 {
	if x != nil {
		return x.ForeignRelayBpsLimit
	}
	return 0
}

func (x *FlagsInConfig) GetMultiThreadCount() uint32 {
	if x != nil {
		return x.MultiThreadCount
	}
	return 0
}

func (x *FlagsInConfig) GetEnableRelayForeignNetworkKcp() bool {
	if x != nil {
		return x.EnableRelayForeignNetworkKcp
	}
	return false
}

func (x *FlagsInConfig) GetEnableRelayForeignNetworkQuic() bool {
	if x != nil {
		return x.EnableRelayForeignNetworkQuic
	}
	return false
}

func (x *FlagsInConfig) GetEncryptionAlgorithm() string {
	if x != nil {
		return x.EncryptionAlgorithm
	}
	return ""
}

func (x *FlagsInConfig) GetDisableSymHolePunching() bool {
	if x != nil {
		return x.DisableSymHolePunching
	}
	return false
}

func (x *FlagsInConfig) GetTldDnsZone() string {
	if x != nil {
		return x.TldDnsZone
	}
	return ""
}

func (x *FlagsInConfig) GetP2POnly() bool {
	if x != nil {
		return x.P2POnly
	}
	return false
}

func (x *FlagsInConfig) GetDisableTcpHolePunching() bool {
	if x != nil {
		return x.DisableTcpHolePunching
	}
	return false
}

func (x *FlagsInConfig) GetLazyP2P() bool {
	if x != nil {
		return x.LazyP2P
	}
	return false
}

func (x *FlagsInConfig) GetNeedP2P() bool {
	if x != nil {
		return x.NeedP2P
	}
	return false
}

func (x *FlagsInConfig) GetInstanceRecvBpsLimit() uint64 {
	if x != nil {
		return x.InstanceRecvBpsLimit
	}
	return 0
}

func (x *FlagsInConfig) GetDisableUpnp() bool {
	if x != nil {
		return x.DisableUpnp
	}
	return false
}

func (x *FlagsInConfig) GetDisableRelayData() bool {
	if x != nil {
		return x.DisableRelayData
	}
	return false
}

func (x *FlagsInConfig) GetEnableUdpBroadcastRelay() bool {
	if x != nil {
		return x.EnableUdpBroadcastRelay
	}
	return false
}

func (x *FlagsInConfig) GetSocketMark() uint32 {
	if x != nil && x.SocketMark != nil {
		return *x.SocketMark
	}
	return 0
}

func (x *FlagsInConfig) GetPreferPeerRelay() bool {
	if x != nil {
		return x.PreferPeerRelay
	}
	return false
}

type RpcDescriptor struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// allow same service registered multiple times in different domain
	DomainName    string `protobuf:"bytes,1,opt,name=domain_name,json=domainName,proto3" json:"domain_name,omitempty"`
	ProtoName     string `protobuf:"bytes,2,opt,name=proto_name,json=protoName,proto3" json:"proto_name,omitempty"`
	ServiceName   string `protobuf:"bytes,3,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	MethodIndex   uint32 `protobuf:"varint,4,opt,name=method_index,json=methodIndex,proto3" json:"method_index,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RpcDescriptor) ProtoMessage() {}

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

func (x *RpcDescriptor) GetDomainName() string {
	if x != nil {
		return x.DomainName
	}
	return ""
}

func (x *RpcDescriptor) GetProtoName() string {
	if x != nil {
		return x.ProtoName
	}
	return ""
}

func (x *RpcDescriptor) GetServiceName() string {
	if x != nil {
		return x.ServiceName
	}
	return ""
}

func (x *RpcDescriptor) GetMethodIndex() uint32 {
	if x != nil {
		return x.MethodIndex
	}
	return 0
}

type RpcRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Deprecated: Marked as deprecated in common.proto.
	Descriptor_   *RpcDescriptor `protobuf:"bytes,1,opt,name=descriptor,proto3" json:"descriptor,omitempty"`
	Request       []byte         `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	TimeoutMs     int32          `protobuf:"varint,3,opt,name=timeout_ms,json=timeoutMs,proto3" json:"timeout_ms,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RpcRequest) ProtoMessage() {}

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

// Deprecated: Marked as deprecated in common.proto.
func (x *RpcRequest) GetDescriptor_() *RpcDescriptor {
	if x != nil {
		return x.Descriptor_
	}
	return nil
}

func (x *RpcRequest) GetRequest() []byte {
	if x != nil {
		return x.Request
	}
	return nil
}

func (x *RpcRequest) GetTimeoutMs() int32 {
	if x != nil {
		return x.TimeoutMs
	}
	return 0
}

// One transport-neutral RPC invocation submitted through a direct ABI.
//
// full_method_name uses the protobuf reflection form:
// "<package>.<service>.<method>" or "<service>.<method>" for an empty package.
type DirectRpcRequest struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	FullMethodName string                 `protobuf:"bytes,1,opt,name=full_method_name,json=fullMethodName,proto3" json:"full_method_name,omitempty"`
	Request        []byte                 `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	TimeoutMs      *uint64                `protobuf:"varint,3,opt,name=timeout_ms,json=timeoutMs,proto3,oneof" json:"timeout_ms,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*DirectRpcRequest) ProtoMessage() {}

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

func (x *DirectRpcRequest) GetFullMethodName() string {
	if x != nil {
		return x.FullMethodName
	}
	return ""
}

func (x *DirectRpcRequest) GetRequest() []byte {
	if x != nil {
		return x.Request
	}
	return nil
}

func (x *DirectRpcRequest) GetTimeoutMs() uint64 {
	if x != nil && x.TimeoutMs != nil {
		return *x.TimeoutMs
	}
	return 0
}

// One process-level management call delegated by the WASI WebClient to its host.
type HostManagementRequest struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	Rpc            *DirectRpcRequest      `protobuf:"bytes,1,opt,name=rpc,proto3" json:"rpc,omitempty"`
	PreparedConfig *string                `protobuf:"bytes,2,opt,name=prepared_config,json=preparedConfig,proto3,oneof" json:"prepared_config,omitempty"`
	// Runtime identity paired with prepared_config without rewriting rpc.request.
	PreparedInstanceId *UUID `protobuf:"bytes,3,opt,name=prepared_instance_id,json=preparedInstanceId,proto3" json:"prepared_instance_id,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*HostManagementRequest) ProtoMessage() {}

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

func (x *HostManagementRequest) GetRpc() *DirectRpcRequest {
	if x != nil {
		return x.Rpc
	}
	return nil
}

func (x *HostManagementRequest) GetPreparedConfig() string {
	if x != nil && x.PreparedConfig != nil {
		return *x.PreparedConfig
	}
	return ""
}

func (x *HostManagementRequest) GetPreparedInstanceId() *UUID {
	if x != nil {
		return x.PreparedInstanceId
	}
	return nil
}

type RpcResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Response      []byte                 `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
	Error         *error1.Error          `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	RuntimeUs     uint64                 `protobuf:"varint,3,opt,name=runtime_us,json=runtimeUs,proto3" json:"runtime_us,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RpcResponse) ProtoMessage() {}

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

func (x *RpcResponse) GetResponse() []byte {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *RpcResponse) GetError() *error1.Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *RpcResponse) GetRuntimeUs() uint64 {
	if x != nil {
		return x.RuntimeUs
	}
	return 0
}

type RpcCompressionInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// use this to compress the content
	Algo CompressionAlgoPb `protobuf:"varint,1,opt,name=algo,proto3,enum=common.CompressionAlgoPb" json:"algo,omitempty"`
	// tell the peer which compression algo is used to compress the next
	// response/request
	AcceptedAlgo  CompressionAlgoPb `protobuf:"varint,2,opt,name=accepted_algo,json=acceptedAlgo,proto3,enum=common.CompressionAlgoPb" json:"accepted_algo,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RpcCompressionInfo) ProtoMessage() {}

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

func (x *RpcCompressionInfo) GetAlgo() CompressionAlgoPb {
	if x != nil {
		return x.Algo
	}
	return CompressionAlgoPb_Invalid
}

func (x *RpcCompressionInfo) GetAcceptedAlgo() CompressionAlgoPb {
	if x != nil {
		return x.AcceptedAlgo
	}
	return CompressionAlgoPb_Invalid
}

type RpcPacket struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	FromPeer        uint32                 `protobuf:"varint,1,opt,name=from_peer,json=fromPeer,proto3" json:"from_peer,omitempty"`
	ToPeer          uint32                 `protobuf:"varint,2,opt,name=to_peer,json=toPeer,proto3" json:"to_peer,omitempty"`
	TransactionId   int64                  `protobuf:"varint,3,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
	Descriptor_     *RpcDescriptor         `protobuf:"bytes,4,opt,name=descriptor,proto3" json:"descriptor,omitempty"`
	Body            []byte                 `protobuf:"bytes,5,opt,name=body,proto3" json:"body,omitempty"`
	IsRequest       bool                   `protobuf:"varint,6,opt,name=is_request,json=isRequest,proto3" json:"is_request,omitempty"`
	TotalPieces     uint32                 `protobuf:"varint,7,opt,name=total_pieces,json=totalPieces,proto3" json:"total_pieces,omitempty"`
	PieceIdx        uint32                 `protobuf:"varint,8,opt,name=piece_idx,json=pieceIdx,proto3" json:"piece_idx,omitempty"`
	TraceId         int32                  `protobuf:"varint,9,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
	CompressionInfo *RpcCompressionInfo    `protobuf:"bytes,10,opt,name=compression_info,json=compressionInfo,proto3" json:"compression_info,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*RpcPacket) ProtoMessage() {}

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

func (x *RpcPacket) GetFromPeer() uint32 {
	if x != nil {
		return x.FromPeer
	}
	return 0
}

func (x *RpcPacket) GetToPeer() uint32 {
	if x != nil {
		return x.ToPeer
	}
	return 0
}

func (x *RpcPacket) GetTransactionId() int64 {
	if x != nil {
		return x.TransactionId
	}
	return 0
}

func (x *RpcPacket) GetDescriptor_() *RpcDescriptor {
	if x != nil {
		return x.Descriptor_
	}
	return nil
}

func (x *RpcPacket) GetBody() []byte {
	if x != nil {
		return x.Body
	}
	return nil
}

func (x *RpcPacket) GetIsRequest() bool {
	if x != nil {
		return x.IsRequest
	}
	return false
}

func (x *RpcPacket) GetTotalPieces() uint32 {
	if x != nil {
		return x.TotalPieces
	}
	return 0
}

func (x *RpcPacket) GetPieceIdx() uint32 {
	if x != nil {
		return x.PieceIdx
	}
	return 0
}

func (x *RpcPacket) GetTraceId() int32 {
	if x != nil {
		return x.TraceId
	}
	return 0
}

func (x *RpcPacket) GetCompressionInfo() *RpcCompressionInfo {
	if x != nil {
		return x.CompressionInfo
	}
	return nil
}

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

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

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

func (*Void) ProtoMessage() {}

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

type UUID struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Part1         uint32                 `protobuf:"varint,1,opt,name=part1,proto3" json:"part1,omitempty"`
	Part2         uint32                 `protobuf:"varint,2,opt,name=part2,proto3" json:"part2,omitempty"`
	Part3         uint32                 `protobuf:"varint,3,opt,name=part3,proto3" json:"part3,omitempty"`
	Part4         uint32                 `protobuf:"varint,4,opt,name=part4,proto3" json:"part4,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UUID) ProtoMessage() {}

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

func (x *UUID) GetPart1() uint32 {
	if x != nil {
		return x.Part1
	}
	return 0
}

func (x *UUID) GetPart2() uint32 {
	if x != nil {
		return x.Part2
	}
	return 0
}

func (x *UUID) GetPart3() uint32 {
	if x != nil {
		return x.Part3
	}
	return 0
}

func (x *UUID) GetPart4() uint32 {
	if x != nil {
		return x.Part4
	}
	return 0
}

type Ipv4Addr struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Addr          uint32                 `protobuf:"varint,1,opt,name=addr,proto3" json:"addr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Ipv4Addr) ProtoMessage() {}

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

func (x *Ipv4Addr) GetAddr() uint32 {
	if x != nil {
		return x.Addr
	}
	return 0
}

type Ipv6Addr struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Part1         uint32                 `protobuf:"varint,1,opt,name=part1,proto3" json:"part1,omitempty"`
	Part2         uint32                 `protobuf:"varint,2,opt,name=part2,proto3" json:"part2,omitempty"`
	Part3         uint32                 `protobuf:"varint,3,opt,name=part3,proto3" json:"part3,omitempty"`
	Part4         uint32                 `protobuf:"varint,4,opt,name=part4,proto3" json:"part4,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Ipv6Addr) ProtoMessage() {}

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

func (x *Ipv6Addr) GetPart1() uint32 {
	if x != nil {
		return x.Part1
	}
	return 0
}

func (x *Ipv6Addr) GetPart2() uint32 {
	if x != nil {
		return x.Part2
	}
	return 0
}

func (x *Ipv6Addr) GetPart3() uint32 {
	if x != nil {
		return x.Part3
	}
	return 0
}

func (x *Ipv6Addr) GetPart4() uint32 {
	if x != nil {
		return x.Part4
	}
	return 0
}

type IpAddr struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Ip:
	//
	//	*IpAddr_Ipv4
	//	*IpAddr_Ipv6
	Ip            isIpAddr_Ip `protobuf_oneof:"ip"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IpAddr) ProtoMessage() {}

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

func (x *IpAddr) GetIp() isIpAddr_Ip {
	if x != nil {
		return x.Ip
	}
	return nil
}

func (x *IpAddr) GetIpv4() *Ipv4Addr {
	if x != nil {
		if x, ok := x.Ip.(*IpAddr_Ipv4); ok {
			return x.Ipv4
		}
	}
	return nil
}

func (x *IpAddr) GetIpv6() *Ipv6Addr {
	if x != nil {
		if x, ok := x.Ip.(*IpAddr_Ipv6); ok {
			return x.Ipv6
		}
	}
	return nil
}

type isIpAddr_Ip interface {
	isIpAddr_Ip()
}

type IpAddr_Ipv4 struct {
	Ipv4 *Ipv4Addr `protobuf:"bytes,1,opt,name=ipv4,proto3,oneof"`
}

type IpAddr_Ipv6 struct {
	Ipv6 *Ipv6Addr `protobuf:"bytes,2,opt,name=ipv6,proto3,oneof"`
}

func (*IpAddr_Ipv4) isIpAddr_Ip() {}

func (*IpAddr_Ipv6) isIpAddr_Ip() {}

type Ipv4Inet struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Address       *Ipv4Addr              `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	NetworkLength uint32                 `protobuf:"varint,2,opt,name=network_length,json=networkLength,proto3" json:"network_length,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Ipv4Inet) ProtoMessage() {}

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

func (x *Ipv4Inet) GetAddress() *Ipv4Addr {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *Ipv4Inet) GetNetworkLength() uint32 {
	if x != nil {
		return x.NetworkLength
	}
	return 0
}

type Ipv6Inet struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Address       *Ipv6Addr              `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	NetworkLength uint32                 `protobuf:"varint,2,opt,name=network_length,json=networkLength,proto3" json:"network_length,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Ipv6Inet) ProtoMessage() {}

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

func (x *Ipv6Inet) GetAddress() *Ipv6Addr {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *Ipv6Inet) GetNetworkLength() uint32 {
	if x != nil {
		return x.NetworkLength
	}
	return 0
}

type IpInet struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Ip:
	//
	//	*IpInet_Ipv4
	//	*IpInet_Ipv6
	Ip            isIpInet_Ip `protobuf_oneof:"ip"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IpInet) ProtoMessage() {}

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

func (x *IpInet) GetIp() isIpInet_Ip {
	if x != nil {
		return x.Ip
	}
	return nil
}

func (x *IpInet) GetIpv4() *Ipv4Inet {
	if x != nil {
		if x, ok := x.Ip.(*IpInet_Ipv4); ok {
			return x.Ipv4
		}
	}
	return nil
}

func (x *IpInet) GetIpv6() *Ipv6Inet {
	if x != nil {
		if x, ok := x.Ip.(*IpInet_Ipv6); ok {
			return x.Ipv6
		}
	}
	return nil
}

type isIpInet_Ip interface {
	isIpInet_Ip()
}

type IpInet_Ipv4 struct {
	Ipv4 *Ipv4Inet `protobuf:"bytes,1,opt,name=ipv4,proto3,oneof"`
}

type IpInet_Ipv6 struct {
	Ipv6 *Ipv6Inet `protobuf:"bytes,2,opt,name=ipv6,proto3,oneof"`
}

func (*IpInet_Ipv4) isIpInet_Ip() {}

func (*IpInet_Ipv6) isIpInet_Ip() {}

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

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

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

func (*Url) ProtoMessage() {}

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

func (x *Url) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

type SocketAddr struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Ip:
	//
	//	*SocketAddr_Ipv4
	//	*SocketAddr_Ipv6
	Ip            isSocketAddr_Ip `protobuf_oneof:"ip"`
	Port          uint32          `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SocketAddr) ProtoMessage() {}

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

func (x *SocketAddr) GetIp() isSocketAddr_Ip {
	if x != nil {
		return x.Ip
	}
	return nil
}

func (x *SocketAddr) GetIpv4() *Ipv4Addr {
	if x != nil {
		if x, ok := x.Ip.(*SocketAddr_Ipv4); ok {
			return x.Ipv4
		}
	}
	return nil
}

func (x *SocketAddr) GetIpv6() *Ipv6Addr {
	if x != nil {
		if x, ok := x.Ip.(*SocketAddr_Ipv6); ok {
			return x.Ipv6
		}
	}
	return nil
}

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

type isSocketAddr_Ip interface {
	isSocketAddr_Ip()
}

type SocketAddr_Ipv4 struct {
	Ipv4 *Ipv4Addr `protobuf:"bytes,1,opt,name=ipv4,proto3,oneof"`
}

type SocketAddr_Ipv6 struct {
	Ipv6 *Ipv6Addr `protobuf:"bytes,2,opt,name=ipv6,proto3,oneof"`
}

func (*SocketAddr_Ipv4) isSocketAddr_Ip() {}

func (*SocketAddr_Ipv6) isSocketAddr_Ip() {}

type TunnelInfo struct {
	state              protoimpl.MessageState `protogen:"open.v1"`
	TunnelType         string                 `protobuf:"bytes,1,opt,name=tunnel_type,json=tunnelType,proto3" json:"tunnel_type,omitempty"`
	LocalAddr          *Url                   `protobuf:"bytes,2,opt,name=local_addr,json=localAddr,proto3" json:"local_addr,omitempty"`
	RemoteAddr         *Url                   `protobuf:"bytes,3,opt,name=remote_addr,json=remoteAddr,proto3" json:"remote_addr,omitempty"`
	ResolvedRemoteAddr *Url                   `protobuf:"bytes,4,opt,name=resolved_remote_addr,json=resolvedRemoteAddr,proto3" json:"resolved_remote_addr,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*TunnelInfo) ProtoMessage() {}

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

func (x *TunnelInfo) GetTunnelType() string {
	if x != nil {
		return x.TunnelType
	}
	return ""
}

func (x *TunnelInfo) GetLocalAddr() *Url {
	if x != nil {
		return x.LocalAddr
	}
	return nil
}

func (x *TunnelInfo) GetRemoteAddr() *Url {
	if x != nil {
		return x.RemoteAddr
	}
	return nil
}

func (x *TunnelInfo) GetResolvedRemoteAddr() *Url {
	if x != nil {
		return x.ResolvedRemoteAddr
	}
	return nil
}

type StunInfo struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	UdpNatType     NatType                `protobuf:"varint,1,opt,name=udp_nat_type,json=udpNatType,proto3,enum=common.NatType" json:"udp_nat_type,omitempty"`
	TcpNatType     NatType                `protobuf:"varint,2,opt,name=tcp_nat_type,json=tcpNatType,proto3,enum=common.NatType" json:"tcp_nat_type,omitempty"`
	LastUpdateTime int64                  `protobuf:"varint,3,opt,name=last_update_time,json=lastUpdateTime,proto3" json:"last_update_time,omitempty"`
	PublicIp       []string               `protobuf:"bytes,4,rep,name=public_ip,json=publicIp,proto3" json:"public_ip,omitempty"`
	MinPort        uint32                 `protobuf:"varint,5,opt,name=min_port,json=minPort,proto3" json:"min_port,omitempty"`
	MaxPort        uint32                 `protobuf:"varint,6,opt,name=max_port,json=maxPort,proto3" json:"max_port,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *StunInfo) Reset() {
	*x = StunInfo{}
	mi := &file_common_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*StunInfo) ProtoMessage() {}

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

func (x *StunInfo) GetUdpNatType() NatType {
	if x != nil {
		return x.UdpNatType
	}
	return NatType_Unknown
}

func (x *StunInfo) GetTcpNatType() NatType {
	if x != nil {
		return x.TcpNatType
	}
	return NatType_Unknown
}

func (x *StunInfo) GetLastUpdateTime() int64 {
	if x != nil {
		return x.LastUpdateTime
	}
	return 0
}

func (x *StunInfo) GetPublicIp() []string {
	if x != nil {
		return x.PublicIp
	}
	return nil
}

func (x *StunInfo) GetMinPort() uint32 {
	if x != nil {
		return x.MinPort
	}
	return 0
}

func (x *StunInfo) GetMaxPort() uint32 {
	if x != nil {
		return x.MaxPort
	}
	return 0
}

type PeerFeatureFlag struct {
	state                  protoimpl.MessageState `protogen:"open.v1"`
	IsPublicServer         bool                   `protobuf:"varint,1,opt,name=is_public_server,json=isPublicServer,proto3" json:"is_public_server,omitempty"`
	AvoidRelayData         bool                   `protobuf:"varint,2,opt,name=avoid_relay_data,json=avoidRelayData,proto3" json:"avoid_relay_data,omitempty"`
	KcpInput               bool                   `protobuf:"varint,3,opt,name=kcp_input,json=kcpInput,proto3" json:"kcp_input,omitempty"`
	NoRelayKcp             bool                   `protobuf:"varint,4,opt,name=no_relay_kcp,json=noRelayKcp,proto3" json:"no_relay_kcp,omitempty"`
	SupportConnListSync    bool                   `protobuf:"varint,5,opt,name=support_conn_list_sync,json=supportConnListSync,proto3" json:"support_conn_list_sync,omitempty"`
	QuicInput              bool                   `protobuf:"varint,6,opt,name=quic_input,json=quicInput,proto3" json:"quic_input,omitempty"`
	NoRelayQuic            bool                   `protobuf:"varint,7,opt,name=no_relay_quic,json=noRelayQuic,proto3" json:"no_relay_quic,omitempty"`
	IsCredentialPeer       bool                   `protobuf:"varint,8,opt,name=is_credential_peer,json=isCredentialPeer,proto3" json:"is_credential_peer,omitempty"`
	NeedP2P                bool                   `protobuf:"varint,9,opt,name=need_p2p,json=needP2p,proto3" json:"need_p2p,omitempty"`
	DisableP2P             bool                   `protobuf:"varint,10,opt,name=disable_p2p,json=disableP2p,proto3" json:"disable_p2p,omitempty"`
	Ipv6PublicAddrProvider bool                   `protobuf:"varint,11,opt,name=ipv6_public_addr_provider,json=ipv6PublicAddrProvider,proto3" json:"ipv6_public_addr_provider,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

func (x *PeerFeatureFlag) Reset() {
	*x = PeerFeatureFlag{}
	mi := &file_common_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PeerFeatureFlag) ProtoMessage() {}

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

func (x *PeerFeatureFlag) GetIsPublicServer() bool {
	if x != nil {
		return x.IsPublicServer
	}
	return false
}

func (x *PeerFeatureFlag) GetAvoidRelayData() bool {
	if x != nil {
		return x.AvoidRelayData
	}
	return false
}

func (x *PeerFeatureFlag) GetKcpInput() bool {
	if x != nil {
		return x.KcpInput
	}
	return false
}

func (x *PeerFeatureFlag) GetNoRelayKcp() bool {
	if x != nil {
		return x.NoRelayKcp
	}
	return false
}

func (x *PeerFeatureFlag) GetSupportConnListSync() bool {
	if x != nil {
		return x.SupportConnListSync
	}
	return false
}

func (x *PeerFeatureFlag) GetQuicInput() bool {
	if x != nil {
		return x.QuicInput
	}
	return false
}

func (x *PeerFeatureFlag) GetNoRelayQuic() bool {
	if x != nil {
		return x.NoRelayQuic
	}
	return false
}

func (x *PeerFeatureFlag) GetIsCredentialPeer() bool {
	if x != nil {
		return x.IsCredentialPeer
	}
	return false
}

func (x *PeerFeatureFlag) GetNeedP2P() bool {
	if x != nil {
		return x.NeedP2P
	}
	return false
}

func (x *PeerFeatureFlag) GetDisableP2P() bool {
	if x != nil {
		return x.DisableP2P
	}
	return false
}

func (x *PeerFeatureFlag) GetIpv6PublicAddrProvider() bool {
	if x != nil {
		return x.Ipv6PublicAddrProvider
	}
	return false
}

type PortForwardConfigPb struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	BindAddr      *SocketAddr            `protobuf:"bytes,1,opt,name=bind_addr,json=bindAddr,proto3" json:"bind_addr,omitempty"`
	DstAddr       *SocketAddr            `protobuf:"bytes,2,opt,name=dst_addr,json=dstAddr,proto3" json:"dst_addr,omitempty"`
	SocketType    SocketType             `protobuf:"varint,3,opt,name=socket_type,json=socketType,proto3,enum=common.SocketType" json:"socket_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PortForwardConfigPb) Reset() {
	*x = PortForwardConfigPb{}
	mi := &file_common_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PortForwardConfigPb) ProtoMessage() {}

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

func (x *PortForwardConfigPb) GetBindAddr() *SocketAddr {
	if x != nil {
		return x.BindAddr
	}
	return nil
}

func (x *PortForwardConfigPb) GetDstAddr() *SocketAddr {
	if x != nil {
		return x.DstAddr
	}
	return nil
}

func (x *PortForwardConfigPb) GetSocketType() SocketType {
	if x != nil {
		return x.SocketType
	}
	return SocketType_TCP
}

type ProxyDstInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DstAddr       *SocketAddr            `protobuf:"bytes,1,opt,name=dst_addr,json=dstAddr,proto3" json:"dst_addr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProxyDstInfo) Reset() {
	*x = ProxyDstInfo{}
	mi := &file_common_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProxyDstInfo) ProtoMessage() {}

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

func (x *ProxyDstInfo) GetDstAddr() *SocketAddr {
	if x != nil {
		return x.DstAddr
	}
	return nil
}

type SecureModeConfig struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	Enabled bool                   `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// base64(X25519 private key), used by shared node to present a stable identity
	LocalPrivateKey *string `protobuf:"bytes,2,opt,name=local_private_key,json=localPrivateKey,proto3,oneof" json:"local_private_key,omitempty"`
	// base64(X25519 public key), required if local_private_key is set
	LocalPublicKey *string `protobuf:"bytes,3,opt,name=local_public_key,json=localPublicKey,proto3,oneof" json:"local_public_key,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *SecureModeConfig) Reset() {
	*x = SecureModeConfig{}
	mi := &file_common_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SecureModeConfig) ProtoMessage() {}

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

func (x *SecureModeConfig) GetEnabled() bool {
	if x != nil {
		return x.Enabled
	}
	return false
}

func (x *SecureModeConfig) GetLocalPrivateKey() string {
	if x != nil && x.LocalPrivateKey != nil {
		return *x.LocalPrivateKey
	}
	return ""
}

func (x *SecureModeConfig) GetLocalPublicKey() string {
	if x != nil && x.LocalPublicKey != nil {
		return *x.LocalPublicKey
	}
	return ""
}

var File_common_proto protoreflect.FileDescriptor

const file_common_proto_rawDesc = "" +
	"\n" +
	"\fcommon.proto\x12\x06common\x1a\verror.proto\"\xf5\x0e\n" +
	"\rFlagsInConfig\x12)\n" +
	"\x10default_protocol\x18\x01 \x01(\tR\x0fdefaultProtocol\x12\x19\n" +
	"\bdev_name\x18\x02 \x01(\tR\adevName\x12+\n" +
	"\x11enable_encryption\x18\x03 \x01(\bR\x10enableEncryption\x12\x1f\n" +
	"\venable_ipv6\x18\x04 \x01(\bR\n" +
	"enableIpv6\x12\x10\n" +
	"\x03mtu\x18\x05 \x01(\rR\x03mtu\x12#\n" +
	"\rlatency_first\x18\x06 \x01(\bR\flatencyFirst\x12(\n" +
	"\x10enable_exit_node\x18\a \x01(\bR\x0eenableExitNode\x12\x15\n" +
	"\x06no_tun\x18\b \x01(\bR\x05noTun\x12\x1f\n" +
	"\vuse_smoltcp\x18\t \x01(\bR\n" +
	"useSmoltcp\x126\n" +
	"\x17relay_network_whitelist\x18\n" +
	" \x01(\tR\x15relayNetworkWhitelist\x12\x1f\n" +
	"\vdisable_p2p\x18\v \x01(\bR\n" +
	"disableP2p\x12+\n" +
	"\x12relay_all_peer_rpc\x18\f \x01(\bR\x0frelayAllPeerRpc\x129\n" +
	"\x19disable_udp_hole_punching\x18\r \x01(\bR\x16disableUdpHolePunching\x12!\n" +
	"\fmulti_thread\x18\x0f \x01(\bR\vmultiThread\x12G\n" +
	"\x12data_compress_algo\x18\x10 \x01(\x0e2\x19.common.CompressionAlgoPbR\x10dataCompressAlgo\x12\x1f\n" +
	"\vbind_device\x18\x11 \x01(\bR\n" +
	"bindDevice\x12(\n" +
	"\x10enable_kcp_proxy\x18\x12 \x01(\bR\x0eenableKcpProxy\x12*\n" +
	"\x11disable_kcp_input\x18\x13 \x01(\bR\x0fdisableKcpInput\x12*\n" +
	"\x11disable_relay_kcp\x18\x14 \x01(\bR\x0fdisableRelayKcp\x125\n" +
	"\x17proxy_forward_by_system\x18\x15 \x01(\bR\x14proxyForwardBySystem\x12\x1d\n" +
	"\n" +
	"accept_dns\x18\x16 \x01(\bR\tacceptDns\x12!\n" +
	"\fprivate_mode\x18\x17 \x01(\bR\vprivateMode\x12*\n" +
	"\x11enable_quic_proxy\x18\x18 \x01(\bR\x0fenableQuicProxy\x12,\n" +
	"\x12disable_quic_input\x18\x19 \x01(\bR\x10disableQuicInput\x12,\n" +
	"\x12disable_relay_quic\x18# \x01(\bR\x10disableRelayQuic\x12,\n" +
	"\x10quic_listen_port\x18! \x01(\rB\x02\x18\x01R\x0equicListenPort\x125\n" +
	"\x17foreign_relay_bps_limit\x18\x1a \x01(\x04R\x14foreignRelayBpsLimit\x12,\n" +
	"\x12multi_thread_count\x18\x1b \x01(\rR\x10multiThreadCount\x12F\n" +
	" enable_relay_foreign_network_kcp\x18\x1c \x01(\bR\x1cenableRelayForeignNetworkKcp\x12H\n" +
	"!enable_relay_foreign_network_quic\x18$ \x01(\bR\x1denableRelayForeignNetworkQuic\x121\n" +
	"\x14encryption_algorithm\x18\x1d \x01(\tR\x13encryptionAlgorithm\x129\n" +
	"\x19disable_sym_hole_punching\x18\x1e \x01(\bR\x16disableSymHolePunching\x12 \n" +
	"\ftld_dns_zone\x18\x1f \x01(\tR\n" +
	"tldDnsZone\x12\x19\n" +
	"\bp2p_only\x18  \x01(\bR\ap2pOnly\x129\n" +
	"\x19disable_tcp_hole_punching\x18\" \x01(\bR\x16disableTcpHolePunching\x12\x19\n" +
	"\blazy_p2p\x18% \x01(\bR\alazyP2p\x12\x19\n" +
	"\bneed_p2p\x18& \x01(\bR\aneedP2p\x125\n" +
	"\x17instance_recv_bps_limit\x18' \x01(\x04R\x14instanceRecvBpsLimit\x12!\n" +
	"\fdisable_upnp\x18( \x01(\bR\vdisableUpnp\x12,\n" +
	"\x12disable_relay_data\x18) \x01(\bR\x10disableRelayData\x12;\n" +
	"\x1aenable_udp_broadcast_relay\x18* \x01(\bR\x17enableUdpBroadcastRelay\x12$\n" +
	"\vsocket_mark\x18+ \x01(\rH\x00R\n" +
	"socketMark\x88\x01\x01\x12*\n" +
	"\x11prefer_peer_relay\x18, \x01(\bR\x0fpreferPeerRelayB\x0e\n" +
	"\f_socket_mark\"\x95\x01\n" +
	"\rRpcDescriptor\x12\x1f\n" +
	"\vdomain_name\x18\x01 \x01(\tR\n" +
	"domainName\x12\x1d\n" +
	"\n" +
	"proto_name\x18\x02 \x01(\tR\tprotoName\x12!\n" +
	"\fservice_name\x18\x03 \x01(\tR\vserviceName\x12!\n" +
	"\fmethod_index\x18\x04 \x01(\rR\vmethodIndex\"\x80\x01\n" +
	"\n" +
	"RpcRequest\x129\n" +
	"\n" +
	"descriptor\x18\x01 \x01(\v2\x15.common.RpcDescriptorB\x02\x18\x01R\n" +
	"descriptor\x12\x18\n" +
	"\arequest\x18\x02 \x01(\fR\arequest\x12\x1d\n" +
	"\n" +
	"timeout_ms\x18\x03 \x01(\x05R\ttimeoutMs\"\x89\x01\n" +
	"\x10DirectRpcRequest\x12(\n" +
	"\x10full_method_name\x18\x01 \x01(\tR\x0efullMethodName\x12\x18\n" +
	"\arequest\x18\x02 \x01(\fR\arequest\x12\"\n" +
	"\n" +
	"timeout_ms\x18\x03 \x01(\x04H\x00R\ttimeoutMs\x88\x01\x01B\r\n" +
	"\v_timeout_ms\"\xc5\x01\n" +
	"\x15HostManagementRequest\x12*\n" +
	"\x03rpc\x18\x01 \x01(\v2\x18.common.DirectRpcRequestR\x03rpc\x12,\n" +
	"\x0fprepared_config\x18\x02 \x01(\tH\x00R\x0epreparedConfig\x88\x01\x01\x12>\n" +
	"\x14prepared_instance_id\x18\x03 \x01(\v2\f.common.UUIDR\x12preparedInstanceIdB\x12\n" +
	"\x10_prepared_config\"l\n" +
	"\vRpcResponse\x12\x1a\n" +
	"\bresponse\x18\x01 \x01(\fR\bresponse\x12\"\n" +
	"\x05error\x18\x02 \x01(\v2\f.error.ErrorR\x05error\x12\x1d\n" +
	"\n" +
	"runtime_us\x18\x03 \x01(\x04R\truntimeUs\"\x83\x01\n" +
	"\x12RpcCompressionInfo\x12-\n" +
	"\x04algo\x18\x01 \x01(\x0e2\x19.common.CompressionAlgoPbR\x04algo\x12>\n" +
	"\raccepted_algo\x18\x02 \x01(\x0e2\x19.common.CompressionAlgoPbR\facceptedAlgo\"\xf4\x02\n" +
	"\tRpcPacket\x12\x1b\n" +
	"\tfrom_peer\x18\x01 \x01(\rR\bfromPeer\x12\x17\n" +
	"\ato_peer\x18\x02 \x01(\rR\x06toPeer\x12%\n" +
	"\x0etransaction_id\x18\x03 \x01(\x03R\rtransactionId\x125\n" +
	"\n" +
	"descriptor\x18\x04 \x01(\v2\x15.common.RpcDescriptorR\n" +
	"descriptor\x12\x12\n" +
	"\x04body\x18\x05 \x01(\fR\x04body\x12\x1d\n" +
	"\n" +
	"is_request\x18\x06 \x01(\bR\tisRequest\x12!\n" +
	"\ftotal_pieces\x18\a \x01(\rR\vtotalPieces\x12\x1b\n" +
	"\tpiece_idx\x18\b \x01(\rR\bpieceIdx\x12\x19\n" +
	"\btrace_id\x18\t \x01(\x05R\atraceId\x12E\n" +
	"\x10compression_info\x18\n" +
	" \x01(\v2\x1a.common.RpcCompressionInfoR\x0fcompressionInfo\"\x06\n" +
	"\x04Void\"^\n" +
	"\x04UUID\x12\x14\n" +
	"\x05part1\x18\x01 \x01(\rR\x05part1\x12\x14\n" +
	"\x05part2\x18\x02 \x01(\rR\x05part2\x12\x14\n" +
	"\x05part3\x18\x03 \x01(\rR\x05part3\x12\x14\n" +
	"\x05part4\x18\x04 \x01(\rR\x05part4\"\x1e\n" +
	"\bIpv4Addr\x12\x12\n" +
	"\x04addr\x18\x01 \x01(\rR\x04addr\"b\n" +
	"\bIpv6Addr\x12\x14\n" +
	"\x05part1\x18\x01 \x01(\rR\x05part1\x12\x14\n" +
	"\x05part2\x18\x02 \x01(\rR\x05part2\x12\x14\n" +
	"\x05part3\x18\x03 \x01(\rR\x05part3\x12\x14\n" +
	"\x05part4\x18\x04 \x01(\rR\x05part4\"^\n" +
	"\x06IpAddr\x12&\n" +
	"\x04ipv4\x18\x01 \x01(\v2\x10.common.Ipv4AddrH\x00R\x04ipv4\x12&\n" +
	"\x04ipv6\x18\x02 \x01(\v2\x10.common.Ipv6AddrH\x00R\x04ipv6B\x04\n" +
	"\x02ip\"]\n" +
	"\bIpv4Inet\x12*\n" +
	"\aaddress\x18\x01 \x01(\v2\x10.common.Ipv4AddrR\aaddress\x12%\n" +
	"\x0enetwork_length\x18\x02 \x01(\rR\rnetworkLength\"]\n" +
	"\bIpv6Inet\x12*\n" +
	"\aaddress\x18\x01 \x01(\v2\x10.common.Ipv6AddrR\aaddress\x12%\n" +
	"\x0enetwork_length\x18\x02 \x01(\rR\rnetworkLength\"^\n" +
	"\x06IpInet\x12&\n" +
	"\x04ipv4\x18\x01 \x01(\v2\x10.common.Ipv4InetH\x00R\x04ipv4\x12&\n" +
	"\x04ipv6\x18\x02 \x01(\v2\x10.common.Ipv6InetH\x00R\x04ipv6B\x04\n" +
	"\x02ip\"\x17\n" +
	"\x03Url\x12\x10\n" +
	"\x03url\x18\x01 \x01(\tR\x03url\"v\n" +
	"\n" +
	"SocketAddr\x12&\n" +
	"\x04ipv4\x18\x01 \x01(\v2\x10.common.Ipv4AddrH\x00R\x04ipv4\x12&\n" +
	"\x04ipv6\x18\x02 \x01(\v2\x10.common.Ipv6AddrH\x00R\x04ipv6\x12\x12\n" +
	"\x04port\x18\x03 \x01(\rR\x04portB\x04\n" +
	"\x02ip\"\xc6\x01\n" +
	"\n" +
	"TunnelInfo\x12\x1f\n" +
	"\vtunnel_type\x18\x01 \x01(\tR\n" +
	"tunnelType\x12*\n" +
	"\n" +
	"local_addr\x18\x02 \x01(\v2\v.common.UrlR\tlocalAddr\x12,\n" +
	"\vremote_addr\x18\x03 \x01(\v2\v.common.UrlR\n" +
	"remoteAddr\x12=\n" +
	"\x14resolved_remote_addr\x18\x04 \x01(\v2\v.common.UrlR\x12resolvedRemoteAddr\"\xed\x01\n" +
	"\bStunInfo\x121\n" +
	"\fudp_nat_type\x18\x01 \x01(\x0e2\x0f.common.NatTypeR\n" +
	"udpNatType\x121\n" +
	"\ftcp_nat_type\x18\x02 \x01(\x0e2\x0f.common.NatTypeR\n" +
	"tcpNatType\x12(\n" +
	"\x10last_update_time\x18\x03 \x01(\x03R\x0elastUpdateTime\x12\x1b\n" +
	"\tpublic_ip\x18\x04 \x03(\tR\bpublicIp\x12\x19\n" +
	"\bmin_port\x18\x05 \x01(\rR\aminPort\x12\x19\n" +
	"\bmax_port\x18\x06 \x01(\rR\amaxPort\"\xc1\x03\n" +
	"\x0fPeerFeatureFlag\x12(\n" +
	"\x10is_public_server\x18\x01 \x01(\bR\x0eisPublicServer\x12(\n" +
	"\x10avoid_relay_data\x18\x02 \x01(\bR\x0eavoidRelayData\x12\x1b\n" +
	"\tkcp_input\x18\x03 \x01(\bR\bkcpInput\x12 \n" +
	"\fno_relay_kcp\x18\x04 \x01(\bR\n" +
	"noRelayKcp\x123\n" +
	"\x16support_conn_list_sync\x18\x05 \x01(\bR\x13supportConnListSync\x12\x1d\n" +
	"\n" +
	"quic_input\x18\x06 \x01(\bR\tquicInput\x12\"\n" +
	"\rno_relay_quic\x18\a \x01(\bR\vnoRelayQuic\x12,\n" +
	"\x12is_credential_peer\x18\b \x01(\bR\x10isCredentialPeer\x12\x19\n" +
	"\bneed_p2p\x18\t \x01(\bR\aneedP2p\x12\x1f\n" +
	"\vdisable_p2p\x18\n" +
	" \x01(\bR\n" +
	"disableP2p\x129\n" +
	"\x19ipv6_public_addr_provider\x18\v \x01(\bR\x16ipv6PublicAddrProvider\"\xaa\x01\n" +
	"\x13PortForwardConfigPb\x12/\n" +
	"\tbind_addr\x18\x01 \x01(\v2\x12.common.SocketAddrR\bbindAddr\x12-\n" +
	"\bdst_addr\x18\x02 \x01(\v2\x12.common.SocketAddrR\adstAddr\x123\n" +
	"\vsocket_type\x18\x03 \x01(\x0e2\x12.common.SocketTypeR\n" +
	"socketType\"=\n" +
	"\fProxyDstInfo\x12-\n" +
	"\bdst_addr\x18\x01 \x01(\v2\x12.common.SocketAddrR\adstAddr\"\xb7\x01\n" +
	"\x10SecureModeConfig\x12\x18\n" +
	"\aenabled\x18\x01 \x01(\bR\aenabled\x12/\n" +
	"\x11local_private_key\x18\x02 \x01(\tH\x00R\x0flocalPrivateKey\x88\x01\x01\x12-\n" +
	"\x10local_public_key\x18\x03 \x01(\tH\x01R\x0elocalPublicKey\x88\x01\x01B\x14\n" +
	"\x12_local_private_keyB\x13\n" +
	"\x11_local_public_key*4\n" +
	"\x11CompressionAlgoPb\x12\v\n" +
	"\aInvalid\x10\x00\x12\b\n" +
	"\x04None\x10\x01\x12\b\n" +
	"\x04Zstd\x10\x02*\xb4\x01\n" +
	"\aNatType\x12\v\n" +
	"\aUnknown\x10\x00\x12\x10\n" +
	"\fOpenInternet\x10\x01\x12\t\n" +
	"\x05NoPAT\x10\x02\x12\f\n" +
	"\bFullCone\x10\x03\x12\x0e\n" +
	"\n" +
	"Restricted\x10\x04\x12\x12\n" +
	"\x0ePortRestricted\x10\x05\x12\r\n" +
	"\tSymmetric\x10\x06\x12\x12\n" +
	"\x0eSymUdpFirewall\x10\a\x12\x14\n" +
	"\x10SymmetricEasyInc\x10\b\x12\x14\n" +
	"\x10SymmetricEasyDec\x10\t*\x1e\n" +
	"\n" +
	"SocketType\x12\a\n" +
	"\x03TCP\x10\x00\x12\a\n" +
	"\x03UDP\x10\x01b\x06proto3"

var (
	file_common_proto_rawDescOnce sync.Once
	file_common_proto_rawDescData []byte
)

func file_common_proto_rawDescGZIP() []byte {
	file_common_proto_rawDescOnce.Do(func() {
		file_common_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_common_proto_rawDesc), len(file_common_proto_rawDesc)))
	})
	return file_common_proto_rawDescData
}

var file_common_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_common_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
var file_common_proto_goTypes = []any{
	(CompressionAlgoPb)(0),        // 0: common.CompressionAlgoPb
	(NatType)(0),                  // 1: common.NatType
	(SocketType)(0),               // 2: common.SocketType
	(*FlagsInConfig)(nil),         // 3: common.FlagsInConfig
	(*RpcDescriptor)(nil),         // 4: common.RpcDescriptor
	(*RpcRequest)(nil),            // 5: common.RpcRequest
	(*DirectRpcRequest)(nil),      // 6: common.DirectRpcRequest
	(*HostManagementRequest)(nil), // 7: common.HostManagementRequest
	(*RpcResponse)(nil),           // 8: common.RpcResponse
	(*RpcCompressionInfo)(nil),    // 9: common.RpcCompressionInfo
	(*RpcPacket)(nil),             // 10: common.RpcPacket
	(*Void)(nil),                  // 11: common.Void
	(*UUID)(nil),                  // 12: common.UUID
	(*Ipv4Addr)(nil),              // 13: common.Ipv4Addr
	(*Ipv6Addr)(nil),              // 14: common.Ipv6Addr
	(*IpAddr)(nil),                // 15: common.IpAddr
	(*Ipv4Inet)(nil),              // 16: common.Ipv4Inet
	(*Ipv6Inet)(nil),              // 17: common.Ipv6Inet
	(*IpInet)(nil),                // 18: common.IpInet
	(*Url)(nil),                   // 19: common.Url
	(*SocketAddr)(nil),            // 20: common.SocketAddr
	(*TunnelInfo)(nil),            // 21: common.TunnelInfo
	(*StunInfo)(nil),              // 22: common.StunInfo
	(*PeerFeatureFlag)(nil),       // 23: common.PeerFeatureFlag
	(*PortForwardConfigPb)(nil),   // 24: common.PortForwardConfigPb
	(*ProxyDstInfo)(nil),          // 25: common.ProxyDstInfo
	(*SecureModeConfig)(nil),      // 26: common.SecureModeConfig
	(*error1.Error)(nil),          // 27: error.Error
}
var file_common_proto_depIdxs = []int32{
	0,  // 0: common.FlagsInConfig.data_compress_algo:type_name -> common.CompressionAlgoPb
	4,  // 1: common.RpcRequest.descriptor:type_name -> common.RpcDescriptor
	6,  // 2: common.HostManagementRequest.rpc:type_name -> common.DirectRpcRequest
	12, // 3: common.HostManagementRequest.prepared_instance_id:type_name -> common.UUID
	27, // 4: common.RpcResponse.error:type_name -> error.Error
	0,  // 5: common.RpcCompressionInfo.algo:type_name -> common.CompressionAlgoPb
	0,  // 6: common.RpcCompressionInfo.accepted_algo:type_name -> common.CompressionAlgoPb
	4,  // 7: common.RpcPacket.descriptor:type_name -> common.RpcDescriptor
	9,  // 8: common.RpcPacket.compression_info:type_name -> common.RpcCompressionInfo
	13, // 9: common.IpAddr.ipv4:type_name -> common.Ipv4Addr
	14, // 10: common.IpAddr.ipv6:type_name -> common.Ipv6Addr
	13, // 11: common.Ipv4Inet.address:type_name -> common.Ipv4Addr
	14, // 12: common.Ipv6Inet.address:type_name -> common.Ipv6Addr
	16, // 13: common.IpInet.ipv4:type_name -> common.Ipv4Inet
	17, // 14: common.IpInet.ipv6:type_name -> common.Ipv6Inet
	13, // 15: common.SocketAddr.ipv4:type_name -> common.Ipv4Addr
	14, // 16: common.SocketAddr.ipv6:type_name -> common.Ipv6Addr
	19, // 17: common.TunnelInfo.local_addr:type_name -> common.Url
	19, // 18: common.TunnelInfo.remote_addr:type_name -> common.Url
	19, // 19: common.TunnelInfo.resolved_remote_addr:type_name -> common.Url
	1,  // 20: common.StunInfo.udp_nat_type:type_name -> common.NatType
	1,  // 21: common.StunInfo.tcp_nat_type:type_name -> common.NatType
	20, // 22: common.PortForwardConfigPb.bind_addr:type_name -> common.SocketAddr
	20, // 23: common.PortForwardConfigPb.dst_addr:type_name -> common.SocketAddr
	2,  // 24: common.PortForwardConfigPb.socket_type:type_name -> common.SocketType
	20, // 25: common.ProxyDstInfo.dst_addr:type_name -> common.SocketAddr
	26, // [26:26] is the sub-list for method output_type
	26, // [26:26] is the sub-list for method input_type
	26, // [26:26] is the sub-list for extension type_name
	26, // [26:26] is the sub-list for extension extendee
	0,  // [0:26] is the sub-list for field type_name
}

func init() { file_common_proto_init() }
func file_common_proto_init() {
	if File_common_proto != nil {
		return
	}
	file_common_proto_msgTypes[0].OneofWrappers = []any{}
	file_common_proto_msgTypes[3].OneofWrappers = []any{}
	file_common_proto_msgTypes[4].OneofWrappers = []any{}
	file_common_proto_msgTypes[12].OneofWrappers = []any{
		(*IpAddr_Ipv4)(nil),
		(*IpAddr_Ipv6)(nil),
	}
	file_common_proto_msgTypes[15].OneofWrappers = []any{
		(*IpInet_Ipv4)(nil),
		(*IpInet_Ipv6)(nil),
	}
	file_common_proto_msgTypes[17].OneofWrappers = []any{
		(*SocketAddr_Ipv4)(nil),
		(*SocketAddr_Ipv6)(nil),
	}
	file_common_proto_msgTypes[23].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_common_proto_rawDesc), len(file_common_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   24,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_common_proto_goTypes,
		DependencyIndexes: file_common_proto_depIdxs,
		EnumInfos:         file_common_proto_enumTypes,
		MessageInfos:      file_common_proto_msgTypes,
	}.Build()
	File_common_proto = out.File
	file_common_proto_goTypes = nil
	file_common_proto_depIdxs = nil
}