dns

type Answer struct {
	Name string     `json:"name"`
	Type RecordType `json:"type"`
	TTL  uint       `json:"ttl"`
	Data string     `json:"data"`
}

type DNS interface {
	// Lookup performs a DNS lookup for the given hostname and returns a valid IP address for the A record.
	Lookup(ctx context.Context, hostname string) (bool, *net.IP, error)
}

type DNSAction interface {
	// GetID returns the unique ID of the DNS action
	GetID() string
	// GetReply returns the reply of the DNS action
	GetReply() string
	// SetReply sets the reply of the DNS action
	SetReply(string)
	// GetAction returns the action of the DNS action
	GetAction() string
}

type DNSAddAction struct {
	DNSBaseAction
	Name  string `json:"name"`
	Type  string `json:"type,omitempty"`
	Value string `json:"value,omitempty"`
	// TTL is the DNS TTL for the record
	TTL time.Duration `json:"ttl,omitempty"`
	// Expires is the expiration time of the DNS record
	// if not provided the record will never expire
	Expires time.Duration `json:"expires,omitempty"`

	// Priority is the priority of the DNS record
	// only used for MX and SRV records
	Priority int `json:"priority,omitempty"`
	// Weight is the weight of the DNS record
	// only used for SRV records
	Weight int `json:"weight,omitempty"`
	// Port is the port of the DNS record
	// only used for SRV records
	Port int `json:"port,omitempty"`
}

type DNSBaseAction struct {
	MsgID  string `json:"msg_id"`
	Action string `json:"action"`
	Reply  string `json:"reply,omitempty"`
}

type DNSCert struct {
	Certificate []byte    `json:"certificate"`
	PrivateKey  []byte    `json:"private_key"`
	Expires     time.Time `json:"expires"`
	// Domain is the name for which the certificate is valid, it may be different from the name requested
	Domain string `json:"domain"`
}

type DNSCertAction struct {
	DNSBaseAction
	Name string `json:"name"`
}

type DNSConfig struct {
	// ListenAddress is the address to bind DNS server to (default: :53)
	ListenAddress string
	// ManagedDomains are domains that should be forwarded to internal nameservers
	ManagedDomains []string
	// InternalNameservers are the nameservers to forward managed domain queries to
	InternalNameservers []string
	// UpstreamNameservers are the nameservers to forward other queries to
	UpstreamNameservers []string
	// Timeout for DNS queries
	QueryTimeout string
	// DialContext is the function to use for dialing connections
	DialContext func(ctx context.Context, network, address string) (net.Conn, error)
	// DefaultProtocol is the default protocol to use for dialing connections which is UDP
	DefaultProtocol string
	// DefaultNegativeTTL is the TTL (in seconds) to use for negative responses when no SOA record
	// is present. Per RFC 2308, negative responses should include an SOA record, but some servers
	// don't comply. Set to 0 to disable caching when SOA is missing. Default is 30 seconds.
	DefaultNegativeTTL uint32
}

type DNSDeleteAction struct {
	DNSBaseAction
	// Name is the name of the DNS record to delete.
	Name string `json:"name"`
	// IDs are the IDs of the DNS records to delete (within a name). This allows for clients to manage a specific record if they keep track of the ID.
	// If not provided, any name match will be deleted.
	IDs []string `json:"ids,omitempty"`
}

type DNSRecord struct {
	IDs []string `json:"ids"`
}

type DNSRecordType string

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

type DNSResponse[T any] struct {
	MsgID   string `json:"msg_id"`
	Success bool   `json:"success"`
	Error   string `json:"error,omitempty"`
	Data    *T     `json:"data,omitempty"`
}

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

type Message struct {
	Payload []byte
}

type ParsedResolvConf struct {
	Nameservers []string
	Search      []string
}

type RecordType uint8

type Result struct {
	Status StatusType `json:"Status"`
	Answer []Answer   `json:"Answer"`
}

type StatusType uint8

type Subscriber interface {
	// Close closes the subscriber
	Close() error
	// Channel returns a channel of messages
	Channel() <-chan *Message
}

type Transport interface {
	Subscribe(ctx context.Context, channel string) Subscriber
	Publish(ctx context.Context, channel string, payload []byte) error
}

type TypedDNSAction[R any] interface {
	DNSAction
	// contains filtered or unexported methods
}

type WithConfig func(config *dnsConfig)