gocent

type BroadcastResult struct {
	Responses []PublishResponse `json:"responses"`
}

type ChannelInfo struct {
	NumUsers int32 `json:"num_users"`
}

type ChannelsOption func(options *ChannelsOptions)

type ChannelsOptions struct {
	// Pattern to filter channels.
	Pattern string `json:"pattern,omitempty"`
}

type ChannelsResult struct {
	Channels map[string]ChannelInfo `json:"channels"`
}

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

type ClientInfo struct {
	User     string          `json:"user"`
	Client   string          `json:"client"`
	ConnInfo json.RawMessage `json:"conn_info,omitempty"`
	ChanInfo json.RawMessage `json:"chan_info,omitempty"`
}

type Command struct {
	Method string      `json:"method"`
	Params interface{} `json:"params"`
}

type Config struct {
	// Addr is Centrifugo API endpoint.
	Addr string
	// GetAddr when set will be used before every API call to extract
	// Centrifugo API endpoint. In this case Addr field of Config will be
	// ignored. Nil value means using static Config.Addr field.
	GetAddr func() (string, error)
	// Key is Centrifugo API key.
	Key string
	// HTTPClient is a custom HTTP client to be used.
	// If nil DefaultHTTPClient will be used.
	HTTPClient *http.Client
}

type Disconnect struct {
	// Code is disconnect code.
	Code uint32 `json:"code,omitempty"`
	// Reason is a short description of disconnect.
	Reason string `json:"reason"`
	// Reconnect gives client an advice to reconnect after disconnect or not.
	Reconnect bool `json:"reconnect"`
}

type DisconnectOption func(options *DisconnectOptions)

type DisconnectOptions struct {
	// Disconnect represents custom disconnect to use.
	// By default DisconnectForceNoReconnect will be used.
	Disconnect *Disconnect
	// ClientWhitelist contains client IDs to keep.
	ClientWhitelist []string
	// ClientID to disconnect.
	ClientID string `json:"client,omitempty"`
}

type ErrStatusCode struct {
	Code int
}

type Error struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
}

type HistoryOption func(options *HistoryOptions)

type HistoryOptions struct {
	// Since used to extract publications from stream since provided StreamPosition.
	Since *StreamPosition `json:"since,omitempty"`
	// Limit number of publications to return.
	// -1 means no limit - i.e. return all publications currently in stream.
	// 0 means that caller only interested in current stream top position so
	// Broker should not return any publications in result.
	// Positive integer does what it should.
	Limit int `json:"limit,omitempty"`
	// Reverse direction.
	Reverse bool `json:"reverse,omitempty"`
}

type HistoryResult struct {
	Publications []Publication `json:"publications"`
	Offset       uint64        `json:"offset"`
	Epoch        string        `json:"epoch"`
}

type InfoResult struct {
	Nodes []NodeInfo `json:"nodes"`
}

type NodeInfo struct {
	// UID is a unique id of running node.
	UID string `json:"uid"`
	// Name is a name of node (config defined or generated automatically).
	Name string `json:"name"`
	// Version of Centrifugo node.
	Version string `json:"version"`
	// NumClients is a number of clients connected to node.
	NumClients int `json:"num_clients"`
	// NumUsers is a number of unique users connected to node.
	NumUsers int `json:"num_users"`
	// NumChannels is a number of channels on node.
	NumChannels int `json:"num_channels"`
	// Uptime of node in seconds.
	Uptime int `json:"uptime"`
}

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

type PresenceResult struct {
	Presence map[string]ClientInfo `json:"presence"`
}

type PresenceStatsResult struct {
	NumUsers   int32 `json:"num_users"`
	NumClients int32 `json:"num_clients"`
}

type Publication struct {
	Offset uint64          `json:"offset"`
	Data   json.RawMessage `json:"data"`
	Info   *ClientInfo     `json:"info"`
}

type PublishOption func(*PublishOptions)

type PublishOptions struct {
	SkipHistory bool `json:"skip_history,omitempty"`
}

type PublishResponse struct {
	Error  *Error         `json:"error"`
	Result *PublishResult `json:"result"`
}

type PublishResult struct {
	Offset uint64 `json:"offset"`
	Epoch  string `json:"epoch"`
}

type Reply struct {
	Error  *Error          `json:"error"`
	Result json.RawMessage `json:"result"`
}

type StreamPosition struct {
	// Offset defines publication incremental offset inside a stream.
	Offset uint64 `json:"offset,omitempty"`
	// Epoch allows handling situations when storage
	// lost stream entirely for some reason (expired or lost after restart) and we
	// want to track this fact to prevent successful recovery from another stream.
	// I.e. for example we have stream [1, 2, 3], then it's lost and new stream
	// contains [1, 2, 3, 4], client that recovers from position 3 will only receive
	// publication 4 missing 1, 2, 3 from new stream. With epoch we can tell client
	// that correct recovery is not possible.
	Epoch string `json:"epoch,omitempty"`
}

type SubscribeOption func(*SubscribeOptions)

type SubscribeOptions struct {
	// ChannelInfo defines custom channel information, zero value means no channel information.
	Info json.RawMessage `json:"info,omitempty"`
	// Presence turns on participating in channel presence.
	Presence bool `json:"presence,omitempty"`
	// JoinLeave enables sending Join and Leave messages for this client in channel.
	JoinLeave bool `json:"join_leave,omitempty"`
	// When position is on client will additionally sync its position inside
	// a stream to prevent message loss. Make sure you are enabling Position in channels
	// that maintain Publication history stream. When Position is on  Centrifuge will
	// include StreamPosition information to subscribe response - for a client to be able
	// to manually track its position inside a stream.
	Position bool `json:"position,omitempty"`
	// Recover turns on recovery option for a channel. In this case client will try to
	// recover missed messages automatically upon resubscribe to a channel after reconnect
	// to a server. This option also enables client position tracking inside a stream
	// (like Position option) to prevent occasional message loss. Make sure you are using
	// Recover in channels that maintain Publication history stream.
	Recover bool `json:"recover,omitempty"`
	// Data to send to a client with Subscribe Push.
	Data json.RawMessage `json:"data,omitempty"`
	// RecoverSince will try to subscribe a client and recover from a certain StreamPosition.
	RecoverSince *StreamPosition `json:"recover_since,omitempty"`
	// ClientID to subscribe.
	ClientID string `json:"client,omitempty"`
}

type UnsubscribeOption func(options *UnsubscribeOptions)

type UnsubscribeOptions struct {
	// ClientID to unsubscribe.
	ClientID string `json:"client,omitempty"`
}