pairing

type AccountData struct {
	Account  *multiaccounts.Account `json:"account,omitempty"`
	Password string                 `json:"password,omitempty"`
	ChatKey  string                 `json:"chatKey,omitempty"`
}

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

type AccountPayloadLoader struct {
	*AccountPayload
	// contains filtered or unexported fields
}

type AccountPayloadMarshaller struct {
	*AccountPayload
	// contains filtered or unexported fields
}

type AccountPayloadStorer struct {
	*AccountPayload
	// contains filtered or unexported fields
}

type Action int

type BaseClient struct {
	*http.Client
	// contains filtered or unexported fields
}

type BasePayloadMounter struct {
	*PayloadLockPayload
	*PayloadToSend
	// contains filtered or unexported fields
}

type BasePayloadReceiver struct {
	*PayloadLockPayload
	*PayloadReceived
	// contains filtered or unexported fields
}

type BaseServer struct {
	server.Server
	// contains filtered or unexported fields
}

type ChallengeError struct {
	Text     string
	HTTPCode int
}

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

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

type ClientConfig struct{}

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

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

type Event struct {
	Type   EventType `json:"type"`
	Error  string    `json:"error,omitempty"`
	Action Action    `json:"action"`
	Data   any       `json:"data,omitempty"`
}

type EventType string

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

type InstallationPayloadMounterReceiver struct {
	PayloadMounter
	PayloadReceiver
}

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

type KeystoreFilesConfig struct {
	KeystorePath   string `json:"keystorePath" validate:"required,keystorepath"`
	LoggedInKeyUID string `json:"loggedInKeyUid" validate:"required,keyuid"`
	Password       string `json:"password" validate:"required"`
}

type KeystoreFilesPayloadLoader struct {
	*AccountPayload
	// contains filtered or unexported fields
}

type KeystoreFilesPayloadStorer struct {
	*AccountPayload
	// contains filtered or unexported fields
}

type KeystoreFilesReceiverClient struct {
	*BaseClient
	// contains filtered or unexported fields
}

type KeystoreFilesReceiverClientConfig struct {
	ReceiverConfig *KeystoreFilesReceiverConfig `json:"receiverConfig" validate:"required"`
	ClientConfig   *ClientConfig                `json:"clientConfig"`
}

type KeystoreFilesReceiverConfig struct {
	KeystoreFilesConfig
	KeypairsToImport []string `json:"keypairsToImport" validate:"required"`
}

type KeystoreFilesSenderConfig struct {
	KeystoreFilesConfig
	KeypairsToExport []string `json:"keypairsToExport" validate:"required"`
}

type KeystoreFilesSenderServer struct {
	*BaseServer
	// contains filtered or unexported fields
}

type KeystoreFilesSenderServerConfig struct {
	SenderConfig *KeystoreFilesSenderConfig `json:"senderConfig" validate:"required"`
	ServerConfig *ServerConfig              `json:"serverConfig" validate:"omitempty,dive"`
}

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

type PayloadLoader interface {
	Load() error
}

type PayloadLockPayload struct {
	*PayloadEncryptor
}

type PayloadLocker interface {
	// LockPayload prevents future excess to outbound safe and received data
	LockPayload()
}

type PayloadMounter interface {
	PayloadLocker

	// Mount Loads the payload into the PayloadManager's state
	Mount() error

	// ToSend returns an outbound safe (encrypted) payload
	ToSend() []byte
}

type PayloadMounterReceiver interface {
	PayloadMounter
	PayloadReceiver
}

type PayloadReceived struct {
	*PayloadEncryptor
}

type PayloadReceiver interface {
	PayloadLocker

	// Receive accepts data from an inbound source into the PayloadReceiver's state
	Receive(data []byte) error

	// Received returns a decrypted and parsed payload from an inbound source
	Received() []byte
}

type PayloadRepository interface {
	PayloadLoader
	PayloadStorer
}

type PayloadStorer interface {
	Store() error
}

type PayloadToSend struct {
	*PayloadEncryptor
}

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

type ProtobufMarshaller interface {
	MarshalProtobuf() ([]byte, error)
}

type ProtobufUnmarshaller interface {
	UnmarshalProtobuf([]byte) error
}

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

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

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

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

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

type ReceiverClient struct {
	*BaseClient
	// contains filtered or unexported fields
}

type ReceiverClientConfig struct {
	ReceiverConfig *ReceiverConfig `json:"receiverConfig" validate:"required"`
	ClientConfig   *ClientConfig   `json:"clientConfig"`
}

type ReceiverConfig struct {
	// nodeConfig is required, but we'll validate it separately
	NodeConfig *params.NodeConfig `json:"nodeConfig"`

	// ReceiverConfig.KeystorePath must not end with keyUID (because keyUID is not known yet)
	KeystorePath string `json:"keystorePath" validate:"required,not_end_keyuid"`

	// DeviceType SendPairInstallation need this information
	DeviceType    string `json:"deviceType" validate:"required"`
	KDFIterations int    `json:"kdfIterations" validate:"gte=0"`

	// SettingCurrentNetwork corresponding to field current_network from table settings, so that we can override current network from sender
	SettingCurrentNetwork string `json:"settingCurrentNetwork" validate:"required"`

	DeviceName     string                  `json:"deviceName"`
	DB             *multiaccounts.Database `json:"-"`
	LoggedInKeyUID string                  `json:"-"`
}

type ReceiverServer struct {
	*BaseServer
	// contains filtered or unexported fields
}

type ReceiverServerConfig struct {
	ReceiverConfig *ReceiverConfig `json:"receiverConfig" validate:"required"`
	ServerConfig   *ServerConfig   `json:"serverConfig" validate:"omitempty,dive"`
}

type SenderClient struct {
	*BaseClient
	// contains filtered or unexported fields
}

type SenderClientConfig struct {
	SenderConfig *SenderConfig `json:"senderConfig" validate:"required"`
	ClientConfig *ClientConfig `json:"clientConfig"`
}

type SenderConfig struct {
	// SenderConfig.KeystorePath must end with keyUID
	KeystorePath string `json:"keystorePath" validate:"required,keystorepath"`
	// DeviceType SendPairInstallation need this information
	DeviceType string `json:"deviceType" validate:"required"`

	KeyUID   string `json:"keyUID" validate:"required,keyuid"`
	Password string `json:"password" validate:"required"`
	ChatKey  string `json:"chatKey"` // set only in case of a Keycard user, otherwise empty

	DB *multiaccounts.Database `json:"-"`
}

type SenderServer struct {
	*BaseServer
	// contains filtered or unexported fields
}

type SenderServerConfig struct {
	SenderConfig *SenderConfig `json:"senderConfig" validate:"required"`
	ServerConfig *ServerConfig `json:"serverConfig" validate:"omitempty,dive"`
}

type ServerConfig struct {
	// Timeout the number of milliseconds after which the pairing server will automatically terminate
	Timeout uint `json:"timeout" validate:"omitempty,gte=0"`

	PK          *ecdsa.PublicKey `json:"-"`
	EK          []byte           `json:"-"`
	Cert        *tls.Certificate `json:"-"`
	ListenIP    net.IP           `json:"-"`
	IPAddresses []net.IP         `json:"-"`
}

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