protocol

type BlockInfo struct {
	Hash   []byte
	Offset int64
	Size   int
}

type ClusterConfig struct {
	Folders   []Folder
	Secondary bool
}

type Compression = bep.Compression

type Connection interface {
	// Send an Index message to the peer device. The message in the
	// parameter may be altered by the connection and should not be used
	// further by the caller.
	Index(ctx context.Context, idx *Index) error

	// Send an Index Update message to the peer device. The message in the
	// parameter may be altered by the connection and should not be used
	// further by the caller.
	IndexUpdate(ctx context.Context, idxUp *IndexUpdate) error

	// Send a Request message to the peer device. The message in the
	// parameter may be altered by the connection and should not be used
	// further by the caller.
	Request(ctx context.Context, req *Request) ([]byte, error)

	// Send a Cluster Configuration message to the peer device. The message
	// in the parameter may be altered by the connection and should not be
	// used further by the caller.
	// For any folder that must be encrypted for the connected device, the
	// password must be provided.
	ClusterConfig(config *ClusterConfig, passwords map[string]string)

	// Send a Download Progress message to the peer device. The message in
	// the parameter may be altered by the connection and should not be used
	// further by the caller.
	DownloadProgress(ctx context.Context, dp *DownloadProgress)

	Start()
	Close(err error)
	DeviceID() DeviceID
	Statistics() Statistics
	Closed() <-chan struct{}

	ConnectionInfo
}

type ConnectionInfo interface {
	Type() string
	Transport() string
	IsLocal() bool
	RemoteAddr() net.Addr
	Priority() int
	String() string
	Crypto() string
	EstablishedAt() time.Time
	ConnectionID() string
}

type Counter struct {
	ID    ShortID
	Value uint64
}

type Device struct {
	ID                       DeviceID
	Name                     string
	Addresses                []string
	Compression              Compression
	CertName                 string
	MaxSequence              int64
	Introducer               bool
	IndexID                  IndexID
	SkipIntroductionRemovals bool
	EncryptionPasswordToken  []byte
}

type DeviceID [DeviceIDLength]byte

type DownloadProgress struct {
	Folder  string
	Updates []FileDownloadProgressUpdate
}

type ErrorCode = bep.ErrorCode

type FileDownloadProgressUpdate struct {
	UpdateType   FileDownloadProgressUpdateType
	Name         string
	Version      Vector
	BlockIndexes []int
	BlockSize    int
}

type FileDownloadProgressUpdateType = bep.FileDownloadProgressUpdateType

type FileInfo struct {
	Name          string
	Size          int64
	ModifiedS     int64
	ModifiedBy    ShortID
	Version       Vector
	Sequence      int64
	Blocks        []BlockInfo
	SymlinkTarget []byte
	BlocksHash    []byte
	Encrypted     []byte
	Platform      PlatformData

	Type         FileInfoType
	Permissions  uint32
	ModifiedNs   int32
	RawBlockSize int32

	// The local_flags fields stores flags that are relevant to the local
	// host only. It is not part of the protocol, doesn't get sent or
	// received (we make sure to zero it), nonetheless we need it on our
	// struct and to be able to serialize it to/from the database.
	// It does carry the info to decide if the file is invalid, which is part of
	// the protocol.
	LocalFlags FlagLocal

	// The version_hash is an implementation detail and not part of the wire
	// format.
	VersionHash []byte

	// The time when the inode was last changed (i.e., permissions, xattrs
	// etc changed). This is host-local, not sent over the wire.
	InodeChangeNs int64

	// The size of the data appended to the encrypted file on disk. This is
	// host-local, not sent over the wire.
	EncryptionTrailerSize int

	Deleted       bool
	NoPermissions bool
	// contains filtered or unexported fields
}

type FileInfoComparison struct {
	ModTimeWindow   time.Duration
	IgnorePerms     bool
	IgnoreBlocks    bool
	IgnoreFlags     FlagLocal
	IgnoreOwnership bool
	IgnoreXattrs    bool
}

type FileInfoType = bep.FileInfoType

type FileInfoWithoutBlocks interface {
	GetName() string
	GetSize() int64
	GetModifiedS() int64
	GetModifiedBy() uint64
	GetVersion() *bep.Vector
	GetSequence() int64
	// GetBlocks() []*bep.BlockInfo // not included
	GetSymlinkTarget() []byte
	GetBlocksHash() []byte
	GetEncrypted() []byte
	GetType() FileInfoType
	GetPermissions() uint32
	GetModifiedNs() int32
	GetBlockSize() int32
	GetPlatform() *bep.PlatformData
	GetLocalFlags() uint32
	GetVersionHash() []byte
	GetInodeChangeNs() int64
	GetEncryptionTrailerSize() int32
	GetDeleted() bool
	GetInvalid() bool
	GetNoPermissions() bool
}

type FlagLocal uint32

type Folder struct {
	ID                 string
	Label              string
	ReadOnly           bool
	IgnorePermissions  bool
	IgnoreDelete       bool
	DisableTempIndexes bool
	Paused             bool
	Devices            []Device
}

type Hello struct {
	DeviceName     string
	ClientName     string
	ClientVersion  string
	NumConnections int
	Timestamp      int64
}

type Index struct {
	Folder       string
	Files        []FileInfo
	LastSequence int64
}

type IndexID uint64

type IndexUpdate struct {
	Folder       string
	Files        []FileInfo
	LastSequence int64
	PrevSequence int64
}

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

type Model interface {
	// An index was received from the peer device
	Index(conn Connection, idx *Index) error
	// An index update was received from the peer device
	IndexUpdate(conn Connection, idxUp *IndexUpdate) error
	// A request was made by the peer device
	Request(conn Connection, req *Request) (RequestResponse, error)
	// A cluster configuration message was received
	ClusterConfig(conn Connection, config *ClusterConfig) error
	// The peer device closed the connection or an error occurred
	Closed(conn Connection, err error)
	// The peer device sent progress updates for the files it is currently downloading
	DownloadProgress(conn Connection, p *DownloadProgress) error
}

type Ordering int

type PlatformData struct {
	Unix    *UnixData
	Windows *WindowsData
	Linux   *XattrData
	Darwin  *XattrData
	FreeBSD *XattrData
	NetBSD  *XattrData
}

type Request struct {
	ID            int
	Folder        string
	Name          string
	Offset        int64
	Size          int
	Hash          []byte
	FromTemporary bool
	BlockNo       int
}

type RequestResponse interface {
	Data() []byte
	Close() // Must always be called once the byte slice is no longer in use
	Wait()  // Blocks until Close is called
}

type Response struct {
	ID   int
	Data []byte
	Code ErrorCode
}

type ShortID uint64

type Statistics struct {
	At            time.Time `json:"at"`
	InBytesTotal  int64     `json:"inBytesTotal"`
	OutBytesTotal int64     `json:"outBytesTotal"`
	StartedAt     time.Time `json:"startedAt"`
}

type UnixData struct {
	// The owner name and group name are set when known (i.e., could be
	// resolved on the source device), while the UID and GID are always set
	// as they come directly from the stat() call.
	OwnerName string
	GroupName string
	UID       int
	GID       int
}

type Vector struct {
	Counters []Counter
}

type WindowsData = bep.WindowsData

type Xattr struct {
	Name  string
	Value []byte
}

type XattrData struct {
	Xattrs []Xattr
}