netapi

type Address interface {
	// Hostname return hostname of address, eg: www.example.com, 127.0.0.1, ff::ff
	Hostname() string
	IPs(context.Context) ([]net.IP, error)
	// IP return net.IP, if address is ip else resolve the domain and return one of ips
	IP(context.Context) (net.IP, error)
	AddrPort(context.Context) Result[netip.AddrPort]
	UDPAddr(context.Context) Result[*net.UDPAddr]
	TCPAddr(context.Context) Result[*net.TCPAddr]
	// Port return port of address
	Port() Port
	// Type return type of address, domain or ip
	Type() Type
	NetworkType() statistic.Type

	net.Addr

	SetSrc(AddressSrc)
	// SetResolver will use call IP(), IPHost(), UDPAddr(), TCPAddr()
	SetResolver(_ Resolver)
	PreferIPv6(b bool)
	// OverrideHostname clone address(exclude Values) and change hostname
	OverrideHostname(string) Address
	OverridePort(Port) Address

	IsFqdn() bool
}

type AddressSrc int32

type ChannelListener struct {
	// contains filtered or unexported fields
}

type ChannelProtocolServer struct {
	// contains filtered or unexported fields
}

type CurrentKey struct{}

type DNSErrCode struct {
	// contains filtered or unexported fields
}

type DNSHandler interface {
	Server
	HandleUDP(context.Context, net.PacketConn) error
	HandleTCP(context.Context, net.Conn) error
	Do(context.Context, *pool.Bytes, func([]byte) error) error
}

type DestinationKey struct{}

type DomainAddr struct {
	// contains filtered or unexported fields
}

type DropResolver struct{}

type DynamicProxy struct {
	// contains filtered or unexported fields
}

type EmptyDispatch struct{}

type EmptyPacketListener struct {
	net.Listener
}

type ErrorResolver func(domain string) error

type FakeIPKey struct{}

type ForceFakeIP struct{}

type IPAddrPort struct {
	// contains filtered or unexported fields
}

type InboundKey struct{}

type Listener interface {
	Stream(context.Context) (net.Listener, error)
	Packet(context.Context) (net.PacketConn, error)
	Server
}

type LogConn struct {
	net.Conn
}

type LookupIPOption struct {
	OnlyAAAA bool
}

type Packet struct {
	Src       net.Addr
	Dst       Address
	WriteBack WriteBack
	Payload   *pool.Bytes
}

type PacketProxy interface {
	PacketConn(context.Context, Address) (net.PacketConn, error)
}

type Port interface {
	Port() uint16
	String() string
}

type PortUint16 uint16

type PreferIPv6 struct{}

type ProtocolServer interface {
	Server
	AcceptStream() (*StreamMeta, error)
	AcceptPacket() (*Packet, error)
}

type Proxy interface {
	StreamProxy
	PacketProxy
	Dispatch(context.Context, Address) (Address, error)
}

type Reader struct {
	io.Reader
}

type Resolver interface {
	LookupIP(ctx context.Context, domain string, opts ...func(*LookupIPOption)) ([]net.IP, error)
	Raw(ctx context.Context, req dnsmessage.Question) (dnsmessage.Message, error)
	io.Closer
}

type Result[T any] struct {
	V   T
	Err error
}

type Server interface {
	io.Closer
}

type SourceKey struct{}

type Store interface {
	Add(k, v any) Store
	Get(k any) (any, bool)
	Range(func(k, v any) bool)
	Map() map[any]any
}

type StreamMeta struct {
	Source      net.Addr
	Destination net.Addr
	Inbound     net.Addr

	Src     net.Conn
	Address Address
}

type StreamProxy interface {
	Conn(context.Context, Address) (net.Conn, error)
}

type SystemResolver struct{ DisableIPv6 bool }

type Type uint8

type WrapListener struct {
	Listener
	// contains filtered or unexported fields
}

type WriteBack func(b []byte, addr net.Addr) (int, error)

type Writer struct {
	io.Writer
}