gun

type Config struct {
	// PeerURLs is the initial set of peer URLs to connect to. This can be empty
	// to not connect to any peers.
	PeerURLs []string
	// Servers is the set of local servers to listen for new peers on. This can
	// be empty to not run any server.
	Servers []Server
	// Storage is the backend storage to locally store data. If not present, a
	// NewStorageInMem is created with a value expiration of
	// DefaultOldestAllowedStorageValue.
	Storage Storage
	// SoulGen is a generator for new soul values. If not present,
	// DefaultSoulGen is used.
	SoulGen func() string
	// PeerErrorHandler is called on every error from or concerning a peer. Not
	// required.
	PeerErrorHandler func(*ErrPeer)
	// PeerSleepOnError is the amount of time we will consider a reconnectable
	// peer "bad" on error before attempting reconnect. If 0 (i.e. not set),
	// DefaultPeerSleepOnError is used.
	PeerSleepOnError time.Duration
	// MyPeerID is the identifier given for this peer to whoever asks. If empty
	// it is set to a random string
	MyPeerID string
	// Tracking is how seen values are updated when they are seen on the wire.
	// When set to TrackingNothing, no seen values will be updated. When set to
	// TrackingRequested (the default), only values that are already in storage
	// will be updated when seen. When set to TrackingEverything, all values
	// seen on the wire will be stored.
	Tracking Tracking
}

type ConflictResolution int

type ErrPeer struct {
	// Err is the error.
	Err error
	// Peer is the peer the error relates to.
	Peer *Peer
}

type FetchResult struct {
	// Err is any error on fetch, local or remote. This can be a context error
	// if the fetch's context completes. This is nil on successful fetch.
	//
	// This may be ErrLookupOnTopLevel for a remote fetch of a top-level field.
	// This may be ErrNotObject if the field is a child of a non-relation value.
	Err error
	// Field is the name of the field that was fetched. It is a convenience
	// value for the scope's field this was originally called on.
	Field string
	// Value is the fetched value. This will be nil if Err is not nil. This will
	// also be nil if a peer said the value does not exist. This will also be
	// nil if the value exists but is nil. Use ValueExists to distinguish
	// between the last two cases.
	Value Value
	// State is the conflict state of the value. It may be 0 for errors. It may
	// also be 0 if this is a top-level field.
	State State
	// ValueExists is true if there is no error and the fetched value, nil or
	// not, does exist.
	ValueExists bool
	// Peer is the peer this result is for. This is nil for results from local
	// storage. This may be nil on error.
	Peer *Peer
}

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

type Message struct {
	Ack  string             `json:"@,omitempty"`
	ID   string             `json:"#,omitempty"`
	To   string             `json:"><,omitempty"`
	Hash json.Number        `json:"##,omitempty"`
	How  string             `json:"how,omitempty"`
	Get  *MessageGetRequest `json:"get,omitempty"`
	Put  map[string]*Node   `json:"put,omitempty"`
	DAM  string             `json:"dam,omitempty"`
	PID  string             `json:"pid,omitempty"`
	OK   int                `json:"ok,omitempty"`
	Err  string             `json:"err,omitempty"`
}

type MessageGetRequest struct {
	Soul  string `json:"#,omitempty"`
	Field string `json:".,omitempty"`
}

type Metadata struct {
	// Soul is the unique identifier of this node.
	Soul string `json:"#,omitempty"`
	// State is the conflict state value for each node field.
	State map[string]State `json:">,omitempty"`
}

type Node struct {
	// Metadata is the metadata for this node.
	Metadata
	// Values is the set of values (including null) keyed by the field name.
	Values map[string]Value
}

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

type PeerConn interface {
	// Send sends the given message (and maybe others) to the peer. The context
	// governs just this send.
	Send(ctx context.Context, msg *Message, moreMsgs ...*Message) error
	// Receive waits for the next message (or set of messages if sent at once)
	// from a peer. The context can be used to control a timeout.
	Receive(ctx context.Context) ([]*Message, error)
	// RemoteURL is the URL this peer is connected via.
	RemoteURL() string
	// Close closes this connection.
	Close() error
}

type PeerConnWebSocket struct {
	Underlying *websocket.Conn
	WriteLock  sync.Mutex
}

type PutOption interface {
	// contains filtered or unexported methods
}

type PutResult struct {
	// Err is any error on put, local or remote. This can be a context error
	// if the put's context completes. This is nil on successful put.
	//
	// This may be ErrLookupOnTopLevel for a remote fetch of a top-level field.
	// This may be ErrNotObject if the field is a child of a non-relation value.
	Err error
	// Field is the name of the field that was put. It is a convenience value
	// for the scope's field this was originally called on.
	Field string
	// Peer is the peer this result is for. This is nil for results from local
	// storage. This may be nil on error.
	Peer *Peer
}

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

type Server interface {
	// Serve is called by Gun to start the server. It should not return until
	// an error occurs or Close is called.
	Serve() error
	// Accept is called to wait for the next peer connection or if an error
	// occurs while trying.
	Accept() (PeerConn, error)
	// Close is called by Gun to stop and close this server.
	Close() error
}

type State float64 // TODO: what if larger?

type Storage interface {
	// Get obtains the value (which can be nil) and state from storage for the
	// given field. If the field does not exist, this errors with
	// ErrStorageNotFound.
	Get(ctx context.Context, parentSoul, field string) (Value, State, error)
	// Put sets the value (which can be nil) and state in storage for the given
	// field if the conflict resolution says it should (see ConflictResolve). It
	// also returns the conflict resolution. If onlyIfExists is true and the
	// field does not exist, this errors with ErrStorageNotFound. Otherwise, if
	// the resulting resolution is an immediate update, it is done. If the
	// resulting resolution is deferred for the future, it is scheduled for then
	// but is not even attempted if context is completed or storage is closed.
	Put(ctx context.Context, parentSoul, field string, val Value, state State, onlyIfExists bool) (ConflictResolution, error)
	// Close closes this storage and disallows future gets or puts.
	Close() error
}

type Tracking int

type Value interface {
	// contains filtered or unexported methods
}

type ValueBool bool

type ValueNumber string

type ValueRelation string

type ValueString string