lib

type AlreadyAMemberError struct{}

type Channel struct {
	Node    *Node
	Subnet  *Subnet
	Name    string
	Lname   string
	Ts      time.Time
	Topic   string
	TopicTs time.Time
	TopicBy string

	LocalMember map[*Client]*Membership
	Member      map[*Client]*Membership

	Mode struct {
		TopicProtected     bool
		NoExternalMessages bool
		Moderated          bool
		Secret             bool
		Limit              uint32
		Key                string
	}
}

type ChannelModeDelta struct {
	TopicProtected, NoExternalMessages, Moderated, Secret ModeDelta
	Limit, Key                                            ModeDelta
	LimitValue                                            uint32
	KeyValue                                              string
}

type Client struct {
	Subnet        *Subnet
	Server        *Server
	Nick, Lnick   string
	Ident, Vident string
	Host, Vhost   string
	Ip, Vip       string
	Gecos         string
	Ts            time.Time
	Member        map[*Channel]*Membership
}

type Config struct {
	// Basic server name and info.
	ServerName, ServerDesc string

	// Network name.
	NetName string

	// Name of the default subnet (must match for networks to link)
	DefaultSubnetName string
}

type EventHandler interface {
	OnServerLink(server *Server, hub *Server)
	OnChannelJoin(channel *Channel, client *Client, membership *Membership)
	OnChannelMessage(from *Client, to *Channel, message string)
	OnChannelModeChange(channel *Channel, by *Client, delta ChannelModeDelta, memberDelta []MemberModeDelta)
	OnPrivateMessage(from *Client, to *Client, message string)
	OnChannelPart(channel *Channel, client *Client, reason string)
}

type Link struct {
	Silence bool
	// contains filtered or unexported fields
}

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

type MemberModeDelta struct {
	Client                                    *Client
	IsOwner, IsAdmin, IsOp, IsHalfop, IsVoice ModeDelta
}

type Membership struct {
	Ts                                        time.Time
	IsOwner, IsAdmin, IsOp, IsHalfop, IsVoice bool
}

type ModeDelta uint8

type NameInUseError struct{}

type Node struct {

	// Map of servers directly connected to this node.
	Local map[*Link]*Server

	// Map of all servers in the network.
	Network map[string]*Server

	NewLinks map[*Link]newLink

	Subnet map[string]*Subnet

	DefaultSubnet *Subnet
	Me            *Server
	Handler       EventHandler
	// contains filtered or unexported fields
}

type NodeDoFn func()

type ProxyEventHandler struct {
	Delegate EventHandler
}

type ResolveClientFn func(name string) (*Client, bool)

type SSBurstComplete struct {
	Server string
}

type SSChannel struct {
	Name    string
	Subnet  string
	Ts      time.Time
	Members []*SSMembership
}

type SSChannelId struct {
	Subnet string
	Name   string
}

type SSChannelMessage struct {
	From    SSClientId
	To      SSChannelId
	Message string
}

type SSChannelMode struct {
	From       SSClientId
	Channel    SSChannelId
	Mode       SSChannelModeDelta
	MemberMode []SSMemberModeDelta
}

type SSChannelModeDelta struct {
	TopicProtected, NoExternalMessages, Moderated, Secret SSModeDelta
	Limit, Key                                            SSModeDelta
	LimitValue                                            uint32
	KeyValue                                              string
}

type SSClient struct {
	Subnet                           string
	Server                           string
	Nick, Ident, Vident, Host, Vhost string
	Ip, Vip                          string
	Gecos                            string
	Ts                               time.Time
}

type SSClientId struct {
	Server string
	Subnet string
	Nick   string
}

type SSHello struct {
	Protocol      uint32
	LocalTimeMs   uint64
	Name          string
	Description   string
	DefaultSubnet string
}

type SSKill struct {
	// Id of the client being killed.
	Id SSClientId

	// Server doing the killing.
	Server string

	// Whether this kill message is instructional (server A telling server B to kill B's client)
	// or authoritative (server B broadcasting a kill of its own client)
	Authority bool

	// If this kill was initiated by another client, who it was.
	By SSClientId

	// Textual reason for the kill.
	Reason string

	// Numerical code indicating the reason for the kill (for statistics, etc).
	ReasonCode SSKillReason
}

type SSKillReason uint8

type SSMemberModeDelta struct {
	Client                                    SSClientId
	IsOwner, IsAdmin, IsOp, IsHalfop, IsVoice SSModeDelta
}

type SSMembership struct {
	Client                                    SSClientId
	Channel                                   SSChannelId
	Ts                                        time.Time
	IsOwner, IsAdmin, IsOp, IsHalfop, IsVoice bool
}

type SSMembershipEnd struct {
	Channel SSChannelId
	Client  SSClientId
	Reason  string
}

type SSMessage interface {
	String() string
	// contains filtered or unexported methods
}

type SSMessageHeader struct {
	Type uint32
}

type SSModeDelta uint8

type SSPrivateMessage struct {
	From    SSClientId
	To      SSClientId
	Message string
}

type SSServer struct {
	Name string
	Desc string
	Via  string
}

type SSSplit struct {
	Server string
	Reason string
}

type SSSync struct {
	Sequence  uint32
	Reply     bool
	Origin    string
	ReplyFrom string
}

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

type SerializeClientFn func(client *Client) string

type Server struct {
	Name string
	Desc string

	Link  *Link
	Route *Server
	Hub   *Server

	Links map[string]*Server
}

type ServerProtocolFactory interface {
	Reader(reader io.Reader) ServerProtocolReader
	Writer(writer io.Writer) ServerProtocolWriter
}

type ServerProtocolReader interface {
	ReadMessage() (msg SSMessage, err error)
}

type ServerProtocolWriter interface {
	WriteMessage(msg SSMessage) error
}

type Subnet struct {
	Name string

	Client  map[string]*Client
	Channel map[string]*Channel
}