dm

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

type Callbacks interface {
	// NotificationUpdate is a callback that is called any time a notification
	// level changes.
	//
	// It returns a [NotificationFilter], which is passed into
	// [GetNotificationReportsForMe] to determine which notifications from the
	// notification server belong to the user.
	//
	// It also returns a slice that contains the [NotificationLevel] for all
	// added and changed DM conversations. The deleted slice contains any
	// conversations that have been deleted.
	NotificationUpdate(nf NotificationFilter,
		changed []NotificationState, deleted []ed25519.PublicKey)

	// BlockedUser is a callback that is called anytime a user is blocked or
	// unblocked. It is also called on initial registration for every blocked
	// user.
	BlockedUser(user ed25519.PublicKey, blocked bool)
}

type ChannelInvitation struct {
	Version    uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	Text       string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	InviteLink string `protobuf:"bytes,3,opt,name=inviteLink,proto3" json:"inviteLink,omitempty"`
	Password   string `protobuf:"bytes,4,opt,name=Password,proto3" json:"Password,omitempty"`
	// contains filtered or unexported fields
}

type Client interface {
	Sender

	// GetPublicKey returns the public key of this client.
	GetPublicKey() nike.PublicKey

	// GetToken returns the DM token of this client.
	GetToken() uint32

	// GetIdentity returns the public identity associated with this client.
	GetIdentity() codename.Identity

	// ExportPrivateIdentity encrypts and exports the private identity to a
	// portable string.
	ExportPrivateIdentity(password string) ([]byte, error)

	// BlockPartner prevents receiving messages and notifications from the
	// partner.
	BlockPartner(partnerPubKey ed25519.PublicKey)

	// UnblockPartner unblocks a blocked sender to allow DM messages.
	UnblockPartner(partnerPubKey ed25519.PublicKey)

	// IsBlocked indicates if the given partner is blocked.
	IsBlocked(partnerPubKey ed25519.PublicKey) bool

	// GetBlockedPartners returns all partners who are blocked by this user.
	GetBlockedPartners() []ed25519.PublicKey

	// GetNotificationLevel returns the notification level for the given channel.
	GetNotificationLevel(
		partnerPubKey ed25519.PublicKey) (NotificationLevel, error)

	// SetMobileNotificationsLevel sets the notification level for the given DM
	// conversation partner.
	SetMobileNotificationsLevel(
		partnerPubKey ed25519.PublicKey, level NotificationLevel) error

	NickNameManager
}

type DeleteMessage struct {
	Version         uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	TargetMessageID []byte `protobuf:"bytes,2,opt,name=targetMessageID,proto3" json:"targetMessageID,omitempty"`
	// contains filtered or unexported fields
}

type DirectMessage struct {

	// The round this message was sent on to the intended recipient
	RoundID uint64 `protobuf:"varint,1,opt,name=RoundID,proto3" json:"RoundID,omitempty"`
	// The round this message was sent on for the self send.
	SelfRoundID uint64 `protobuf:"varint,2,opt,name=SelfRoundID,proto3" json:"SelfRoundID,omitempty"`
	DMToken     uint32 `protobuf:"varint,3,opt,name=DMToken,proto3" json:"DMToken,omitempty"` // hash of private key of the sender
	// The type the below payload is (currently a Text or Reaction)
	PayloadType uint32 `protobuf:"varint,4,opt,name=PayloadType,proto3" json:"PayloadType,omitempty"`
	// Payload is the actual message payload. It will be processed differently
	// based on the PayloadType.
	Payload []byte `protobuf:"bytes,5,opt,name=Payload,proto3" json:"Payload,omitempty"`
	// nickname is the name which the user is using for this message it will not
	// be longer than 24 characters.
	Nickname string `protobuf:"bytes,6,opt,name=Nickname,proto3" json:"Nickname,omitempty"`
	// Nonce is 32 bits of randomness to ensure that two messages in the same
	// round with that have the same nickname, payload, and lease will not have
	// the same message ID.
	Nonce []byte `protobuf:"bytes,7,opt,name=Nonce,proto3" json:"Nonce,omitempty"`
	// LocalTimestamp is the timestamp when the "send call" is made based upon
	// the local clock. If this differs by more than 5 seconds +/- from when the
	// round it sent on is queued, then a random mutation on the queued time
	// (+/- 200ms) will be used by local clients instead.
	LocalTimestamp int64 `protobuf:"varint,8,opt,name=LocalTimestamp,proto3" json:"LocalTimestamp,omitempty"`
	// contains filtered or unexported fields
}

type EventModel interface {
	// Receive is called whenever a raw direct message is
	// received. It may be called multiple times on the same
	// message. It is incumbent on the user of the API to filter
	// such called by message ID.
	//
	// Receive includes the message Type so that the implementor
	// can determine what to do with the message.
	//
	// The API needs to return a UUID of the message that can be
	// referenced at a later time.
	//
	// messageID, timestamp, and round are all nillable and may be
	// updated based upon the UUID at a later date. A time of
	// time.Time{} will be passed for a nilled timestamp.
	//
	// Nickname may be empty, in which case the UI is expected to
	// display the codename.
	Receive(messageID cryptoMessage.ID,
		nickname string, text []byte,
		partnerPubKey, senderPubKey ed25519.PublicKey,
		partnerToken uint32,
		codeset uint8, timestamp time.Time,
		round rounds.Round, mType MessageType, status Status) uint64

	// ReceiveText is called whenever a direct message is
	// received. It may be called multiple times on the same
	// message. It is incumbent on the user of the API to filter
	// such called by message ID.
	//
	// The API needs to return a UUID of the message that can be
	// referenced at a later time.
	//
	// messageID, timestamp, and round are all nillable and may be
	// updated based upon the UUID at a later date. A time of
	// time.Time{} will be passed for a nilled timestamp.
	//
	// Nickname may be empty, in which case the UI is expected to
	// display the codename.
	ReceiveText(messageID cryptoMessage.ID,
		nickname, text string,
		partnerPubKey, senderPubKey ed25519.PublicKey,
		partnerToken uint32,
		codeset uint8, timestamp time.Time,
		round rounds.Round, status Status) uint64

	// ReceiveReply is called whenever a direct message is
	// received that is a reply. It may be called multiple times
	// on the same message. It is incumbent on the user of the API
	// to filter such called by message ID.
	//
	// Messages may arrive our of order, so a reply, in theory,
	// can arrive before the initial message. As a result, it may
	// be important to buffer replies.
	//
	// The API needs to return a UUID of the message that can be
	// referenced at a later time.
	//
	// messageID, timestamp, and round are all nillable and may be
	// updated based upon the UUID at a later date. A time of
	// time.Time{} will be passed for a nilled timestamp.
	//
	// Nickname may be empty, in which case the UI is expected to
	// display the codename.
	ReceiveReply(messageID cryptoMessage.ID,
		reactionTo cryptoMessage.ID, nickname, text string,
		partnerPubKey, senderPubKey ed25519.PublicKey,
		partnerToken uint32, codeset uint8,
		timestamp time.Time, round rounds.Round,
		status Status) uint64

	// ReceiveReaction is called whenever a reaction to a direct
	// message is received. It may be called multiple times on the
	// same reaction. It is incumbent on the user of the API to
	// filter such called by message ID.
	//
	// Messages may arrive our of order, so a reply, in theory,
	// can arrive before the initial message. As a result, it may
	// be important to buffer replies.
	//
	// The API needs to return a UUID of the message that can be
	// referenced at a later time.
	//
	// messageID, timestamp, and round are all nillable and may be
	// updated based upon the UUID at a later date. A time of
	// time.Time{} will be passed for a nilled timestamp.
	//
	// Nickname may be empty, in which case the UI is expected to
	// display the codename.
	ReceiveReaction(messageID cryptoMessage.ID,
		reactionTo cryptoMessage.ID, nickname, reaction string,
		partnerPubKey, senderPubKey ed25519.PublicKey,
		partnerToken uint32, codeset uint8,
		timestamp time.Time, round rounds.Round,
		status Status) uint64

	// UpdateSentStatus is called whenever the sent status of a message has
	// changed.
	//
	// messageID, timestamp, and round are all nillable and may be
	// updated based upon the UUID at a later date. A time of
	// time.Time{} will be passed for a nilled timestamp. If a nil
	// value is passed, make no update.
	UpdateSentStatus(uuid uint64, messageID cryptoMessage.ID,
		timestamp time.Time, round rounds.Round, status Status)

	// DeleteMessage deletes the message with the given message.ID belonging to
	// the sender. If the message exists and belongs to the sender, then it is
	// deleted and DeleteMessage returns true. If it does not exist, it returns
	// false.
	DeleteMessage(messageID cryptoMessage.ID, senderPubKey ed25519.PublicKey) bool

	// GetConversation returns any conversations held by the
	// model (receiver)
	GetConversation(senderPubKey ed25519.PublicKey) *ModelConversation

	// GetConversations returns any conversations held by the
	// model (receiver)
	GetConversations() []ModelConversation
}

type MessageType uint16

type ModelConversation struct {
	Pubkey         []byte `json:"pub_key"`
	Nickname       string `json:"nickname"`
	Token          uint32 `json:"token"`
	CodesetVersion uint8  `json:"codeset_version"`

	// Deprecated: KV is the source of truth for blocked users.
	BlockedTimestamp *time.Time `json:"blocked_timestamp"`
}

type NickNameManager interface {
	// GetNickname gets the nickname associated with this DM user.
	GetNickname() (string, bool)
	// SetNickname sets the nickname to use for this user.
	SetNickname(nick string) error
}

type NotificationFilter struct {
	// Identifier is this user's public key. It is set by a partner on the
	// message.CompressedService when sending a DM message.
	Identifier []byte `json:"identifier"`

	// MyID is this user's reception ID.
	MyID *id.ID `json:"myID"`

	// Tags is a list of all SIH tags for each DM partner. It is used to ensure
	// a received notification is from a valid DM partner.
	Tags []string `json:"tags"`

	// PublicKeys is a map of tags to their public keys. Used to identify the
	// owner of the message triggering a notification.
	PublicKeys map[string]ed25519.PublicKey `json:"publicKeys"`

	// List of MessageType to notify on.
	AllowedTypes map[MessageType]struct{} `json:"allowedTypes"`
}

type NotificationLevel uint8

type NotificationReport struct {
	// Public key of DM partner.
	Partner ed25519.PublicKey `json:"partner"`

	// Type is the MessageType of the message that the notification belongs to.
	Type MessageType `json:"type"`
}

type NotificationState struct {
	// PubKey is the Ed25519 public key of the DM conversation partner.
	PubKey ed25519.PublicKey `json:"pubKey"`

	// Level is the notification level for the DM conversation.
	Level NotificationLevel `json:"level"`
}

type NotificationUpdate func(nf NotificationFilter,
	changed []NotificationState, deleted []ed25519.PublicKey)

type NotificationsManager interface {
	Set(toBeNotifiedOn *id.ID, group string, metadata []byte,
		status clientNotif.NotificationState) error
}

type Reaction struct {
	Version           uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	Reaction          string `protobuf:"bytes,2,opt,name=reaction,proto3" json:"reaction,omitempty"`
	ReactionMessageID []byte `protobuf:"bytes,3,opt,name=reactionMessageID,proto3" json:"reactionMessageID,omitempty"`
	// contains filtered or unexported fields
}

type ReceiverBuilder func(path string) (EventModel, error)

type SendTracker interface {
	// Init is used by the DM Client to register trigger and
	// update functions and start send tracking
	Init(net cMixClient, trigger triggerEventFunc,
		updateStatus updateStatusFunc, rng *fastRNG.StreamGenerator)

	// DenotePendingSend registers a new message to be tracked for sending
	DenotePendingSend(partnerPublicKey, senderPubKey ed25519.PublicKey,
		partnerToken uint32,
		messageType MessageType,
		msg *DirectMessage) (uuid uint64, err error)

	// FailedSend marks a message failed
	FailedSend(uuid uint64) error

	// Sent marks a message successfully Sent
	Sent(uuid uint64, msgID cryptoMessage.ID, round rounds.Round) error

	// CheckIfSent checks if the given message was a sent message
	CheckIfSent(messageID cryptoMessage.ID, r rounds.Round) bool

	// Delivered marks a message delivered
	Delivered(msgID cryptoMessage.ID, round rounds.Round) bool

	// StopTracking stops tracking a message
	StopTracking(msgID cryptoMessage.ID, round rounds.Round) bool
}

type Sender interface {
	// SendText is used to send a formatted message to another user.
	SendText(partnerPubKey ed25519.PublicKey, partnerToken uint32,
		msg string, params cmix.CMIXParams) (
		cryptoMessage.ID, rounds.Round, ephemeral.Id, error)

	// SendReply is used to send a formatted direct message reply.
	//
	// If the message ID that the reply is sent to does not exist,
	// then the other side will post the message as a normal
	// message and not as a reply.
	SendReply(partnerPubKey ed25519.PublicKey, partnerToken uint32,
		msg string, replyTo cryptoMessage.ID,
		params cmix.CMIXParams) (cryptoMessage.ID, rounds.Round,
		ephemeral.Id, error)

	// SendReaction is used to send a reaction to a direct
	// message. The reaction must be a single emoji with no other
	// characters, and will be rejected otherwise.
	//
	// Clients will drop the reaction if they do not recognize the reactTo
	// message.
	SendReaction(partnerPubKey ed25519.PublicKey, partnerToken uint32,
		reaction string, reactTo cryptoMessage.ID,
		params cmix.CMIXParams) (cryptoMessage.ID, rounds.Round,
		ephemeral.Id, error)

	// SendInvite is used to send to a DM partner an invitation to another
	// channel.
	SendInvite(partnerPubKey ed25519.PublicKey,
		partnerToken uint32, msg string, inviteTo *cryptoBroadcast.Channel,
		host string, params cmix.CMIXParams) (
		cryptoMessage.ID, rounds.Round, ephemeral.Id, error)

	// SendSilent is used to send to a channel a message with no notifications.
	// Its primary purpose is to communicate new nicknames without calling
	// SendMessage.
	//
	// It takes no payload intentionally as the message should be very
	// lightweight.
	SendSilent(partnerPubKey ed25519.PublicKey, partnerToken uint32,
		params cmix.CMIXParams) (
		cryptoMessage.ID, rounds.Round, ephemeral.Id, error)

	// DeleteMessage sends a message to the partner to delete a message this
	// user sent. Also deletes it from the local database.
	DeleteMessage(partnerPubKey ed25519.PublicKey, partnerToken uint32,
		targetMessage cryptoMessage.ID, params cmix.CMIXParams) (
		cryptoMessage.ID, rounds.Round, ephemeral.Id, error)

	// Send is used to send a raw message. In general, it
	// should be wrapped in a function that defines the wire protocol.
	//
	// If the final message, before being sent over the wire, is
	// too long, this will return an error. Due to the underlying
	// encoding using compression, it is not possible to define
	// the largest payload that can be sent, but it will always be
	// possible to send a payload of 802 bytes at a minimum.
	Send(partnerPubKey ed25519.PublicKey, partnerToken uint32,
		messageType MessageType, plaintext []byte,
		params cmix.CMIXParams) (cryptoMessage.ID,
		rounds.Round, ephemeral.Id, error)
}

type SilentMessage struct {
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type Status uint8

type Text struct {
	Version        uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	Text           string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	ReplyMessageID []byte `protobuf:"bytes,3,opt,name=replyMessageID,proto3" json:"replyMessageID,omitempty"`
	// contains filtered or unexported fields
}