cord

type Debugger interface {
	// Incoming is called with the raw packet string sent to cord, after
	// inflation for gzipped strings.
	Incoming(b []byte)

	// Outgoing is called with data when a packet is sent on cord.
	Outgoing(b []byte)

	// Called when the websocket tries to connect to a server.
	Connecting(endpoint string)

	// Error is called when an error occurs on the socket. The error
	// is ALSO sent down the Errs() channel for your
	Error(error)
}

type DisruptionError struct{ Cause error }

type FatalError struct{ Cause error }

type GatewayRetriever interface {
	// Gateway returns the gateway URL to connect to.
	Gateway() (url string, err error)
}

type HTTPGatewayRetriever struct {
	Client  *http.Client
	BaseURL string
}

type Operation uint8

type Payload struct {
	Operation Operation       `json:"op"`
	Data      json.RawMessage `json:"d"`
	// Provided only for Dispatch operations:
	Sequence uint64 `json:"s"`
	Event    string `json:"t"`
}

type Socket interface {
	// Send dispatches an event down the Discord socket. It returns an error
	// if there was any issue in sending it.
	Send(op Operation, data json.Marshaler) error

	// On attaches a handler to an event.
	On(h events.Handler)

	// On attaches a handler that's called once when an event happens.
	Once(h events.Handler)

	// Off detaches a previously-attached handler from an event.
	Off(h events.Handler)

	// Errs returns a channel of errors which may occur asynchronously
	// on the websocket.
	Errs() <-chan error

	// Frees resources associated with the socket.
	Close() error
}

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

type WsOptions struct {
	// Handshake packet to send to the server. Note that `compress` and
	// `properties` will be filled for you.
	Handshake *model.Handshake

	// How long to wait without frames or acknowledgment before we consider
	// the server to be dead. Defaults to ten seconds.
	Timeout time.Duration

	// Backoff determines how long to wait between reconnections to the
	// websocket server. Defaults to an exponential backoff.
	Backoff backoff.BackOff

	// Dialer to use for the websocket. Defaults to a dialer with the
	// `timeout` duration.
	Dialer *websocket.Dialer

	// The retriever to get the gateway to connect to. Defaults to the
	// HTTPGatewayRetriever with the given `timeout`.
	Gateway GatewayRetriever

	// Debugger struct we log incoming/outgoing messages to.
	Debugger Debugger

	// Headers to send in the websocket handshake.
	Header http.Header
}