channels

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

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

type AddServiceFn func(sp xxdk.Service) error

type AllowLists struct {
	// AllowWithTags is a list of message types that are not filtered when
	// there are Tags.
	AllowWithTags map[MessageType]struct{} `json:"allowWithTags"`

	// AllowWithoutTags is a list of message types that are not filtered when
	// there are no Tags.
	AllowWithoutTags map[MessageType]struct{} `json:"allowWithoutTags"`
}

type CMIXChannelDelete struct {
	Version   uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	MessageID []byte `protobuf:"bytes,2,opt,name=messageID,proto3" json:"messageID,omitempty"` // The [channel.MessageID] of the message to delete
	// contains filtered or unexported fields
}

type CMIXChannelInvitation 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 CMIXChannelMute struct {
	Version    uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	PubKey     []byte `protobuf:"bytes,2,opt,name=pubKey,proto3" json:"pubKey,omitempty"`          // The [ed25519.PublicKey] of the user to mute
	UndoAction bool   `protobuf:"varint,3,opt,name=undoAction,proto3" json:"undoAction,omitempty"` // If true, the user is un-muted
	// contains filtered or unexported fields
}

type CMIXChannelPinned struct {
	Version    uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	MessageID  []byte `protobuf:"bytes,2,opt,name=messageID,proto3" json:"messageID,omitempty"`    // The [channel.MessageID] of the message to pin
	UndoAction bool   `protobuf:"varint,3,opt,name=undoAction,proto3" json:"undoAction,omitempty"` // If true, the message is unpinned
	// contains filtered or unexported fields
}

type CMIXChannelReaction 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 CMIXChannelSilentMessage struct {
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type CMIXChannelText 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
}

type ChannelMessage struct {

	// Lease is the length that this channel message will take effect.
	Lease int64 `protobuf:"varint,1,opt,name=Lease,proto3" json:"Lease,omitempty"`
	// The round this message was sent on.
	RoundID uint64 `protobuf:"varint,2,opt,name=RoundID,proto3" json:"RoundID,omitempty"`
	// Payload is the actual message payload. It will be processed differently
	// based on the PayloadType.
	Payload []byte `protobuf:"bytes,4,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,5,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,6,opt,name=Nonce,proto3" json:"Nonce,omitempty"`
	// LocalTimestamp is the timestamp (unix nanoseconds) 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,7,opt,name=LocalTimestamp,proto3" json:"LocalTimestamp,omitempty"`
	DMToken        uint32 `protobuf:"varint,8,opt,name=DMToken,proto3" json:"DMToken,omitempty"` // hash of private key
	// contains filtered or unexported fields
}

type Client interface {
	GetMaxMessageLength() int
	SendWithAssembler(recipient *id.ID, assembler cmix.MessageAssembler,
		cmixParams cmix.CMIXParams) (rounds.Round, ephemeral.Id, error)
	AddIdentity(id *id.ID, validUntil time.Time, persistent bool,
		fallthroughProcessor message.Processor)
	AddIdentityWithHistory(
		id *id.ID, validUntil, beginning time.Time,
		persistent bool, fallthroughProcessor message.Processor)
	RemoveIdentity(id *id.ID)
	AddService(clientID *id.ID, newService message.Service,
		response message.Processor)
	UpsertCompressedService(clientID *id.ID, newService message.CompressedService,
		response message.Processor)
	DeleteClientService(clientID *id.ID)
	IsHealthy() bool
	AddHealthCallback(f func(bool)) uint64
	RemoveHealthCallback(uint64)
	GetRoundResults(timeout time.Duration, roundCallback cmix.RoundEventCallback,
		roundList ...id.Round)
}

type CommandMessage struct {
	// ChannelID is the ID of the channel.
	ChannelID *id.ID `json:"channelID,omitempty"`

	// MessageID is the ID of the message.
	MessageID message.ID `json:"messageID,omitempty"`

	// MessageType is the Type of channel message.
	MessageType MessageType `json:"messageType,omitempty"`

	// Nickname is the nickname of the sender.
	Nickname string `json:"nickname,omitempty"`

	// Content is the message contents. In most cases, this is the various
	// marshalled proto messages (e.g., channels.CMIXChannelText and
	// channels.CMIXChannelDelete).
	Content []byte `json:"content,omitempty"`

	// EncryptedPayload is the encrypted contents of the received format.Message
	// (with its outer layer of encryption removed). This is the encrypted
	// channels.ChannelMessage.
	EncryptedPayload []byte `json:"encryptedPayload,omitempty"`

	// PubKey is the Ed25519 public key of the sender.
	PubKey ed25519.PublicKey `json:"pubKey,omitempty"`

	// Codeset is the codeset version.
	Codeset uint8 `json:"codeset,omitempty"`

	// Timestamp is the time that the round was queued. It is set by the
	// listener to be either ChannelMessage.LocalTimestamp or the timestamp for
	// states.QUEUED of the round it was sent on, if that is significantly later
	// than OriginatingTimestamp. If the message is a replay, then Timestamp
	// will
	// always be the queued time of the round.
	Timestamp time.Time `json:"timestamp,omitempty"`

	// OriginatingTimestamp is the time the sender queued the message for
	// sending on their client.
	OriginatingTimestamp time.Time `json:"originatingTimestamp,omitempty"`

	// Lease is how long the message should persist.
	Lease time.Duration `json:"lease,omitempty"`

	// OriginatingRound is the ID of the round the message was originally sent
	// on.
	OriginatingRound id.Round `json:"originatingRound,omitempty"`

	// Round is the information about the round the message was sent on. For
	// replay messages, this is the round of the most recent replay, not the
	// round of the original message.
	Round rounds.Round `json:"round,omitempty"`

	// Status is the current status of the message. It is set to Delivered by
	// the listener.
	Status SentStatus `json:"status,omitempty"`

	// FromAdmin indicates if the message came from the channel admin.
	FromAdmin bool `json:"fromAdmin,omitempty"`

	// UserMuted indicates if the sender of the message is muted.
	UserMuted bool `json:"userMuted,omitempty"`
}

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

type EventModel interface {
	// JoinChannel is called whenever a channel is joined locally.
	JoinChannel(channel *cryptoBroadcast.Channel)

	// LeaveChannel is called whenever a channel is left locally.
	LeaveChannel(channelID *id.ID)

	// ReceiveMessage is called whenever a message is received on a given
	// channel. 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.
	//
	// messageType type is included in the call; it will always be Text (1) for
	// this call, but it may be required in downstream databases.
	ReceiveMessage(channelID *id.ID, messageID message.ID, nickname,
		text string, pubKey ed25519.PublicKey, dmToken uint32, codeset uint8,
		timestamp time.Time, lease time.Duration, round rounds.Round,
		messageType MessageType, status SentStatus, hidden bool) uint64

	// ReceiveReply is called whenever a message is received that is a reply on
	// a given channel. 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.
	//
	// messageType type is included in the call; it will always be Text (1) for
	// this call, but it may be required in downstream databases.
	ReceiveReply(channelID *id.ID, messageID, reactionTo message.ID, nickname,
		text string, pubKey ed25519.PublicKey, dmToken uint32, codeset uint8,
		timestamp time.Time, lease time.Duration, round rounds.Round,
		messageType MessageType, status SentStatus, hidden bool) uint64

	// ReceiveReaction is called whenever a reaction to a message is received on
	// a given channel. 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.
	//
	// messageType type is included in the call; it will always be Text (1) for
	// this call, but it may be required in downstream databases.
	ReceiveReaction(channelID *id.ID, messageID, reactionTo message.ID,
		nickname, reaction string, pubKey ed25519.PublicKey, dmToken uint32,
		codeset uint8, timestamp time.Time, lease time.Duration,
		round rounds.Round, messageType MessageType, status SentStatus,
		hidden bool) uint64

	// UpdateFromUUID is called whenever a message at the UUID is modified.
	//
	// messageID, timestamp, round, pinned, hidden, and status are all nillable
	// and may be updated based upon the UUID at a later date. If a nil value is
	// passed, then make no update.
	//
	// Returns an error if the message cannot be updated. It must return
	// NoMessageErr if the message does not exist.
	UpdateFromUUID(uuid uint64, messageID *message.ID, timestamp *time.Time,
		round *rounds.Round, pinned, hidden *bool, status *SentStatus) error

	// UpdateFromMessageID is called whenever a message with the message ID is
	// modified.
	//
	// The API needs to return the UUID of the modified message that can be
	// referenced at a later time.
	//
	// timestamp, round, pinned, hidden, and status are all nillable and may be
	// updated based upon the UUID at a later date. If a nil value is passed,
	// then make no update.
	//
	// Returns an error if the message cannot be updated. It must return
	// NoMessageErr if the message does not exist.
	UpdateFromMessageID(messageID message.ID, timestamp *time.Time,
		round *rounds.Round, pinned, hidden *bool, status *SentStatus) (
		uint64, error)

	// GetMessage returns the message with the given channel.MessageID.
	//
	// Returns an error if the message cannot be gotten. It must return
	// NoMessageErr if the message does not exist.
	GetMessage(messageID message.ID) (ModelMessage, error)

	// DeleteMessage deletes the message with the given [channel.MessageID] from
	// the database.
	//
	// Returns an error if the message cannot be deleted. It must return
	// NoMessageErr if the message does not exist.
	DeleteMessage(messageID message.ID) error

	// MuteUser is called whenever a user is muted or unmuted.
	MuteUser(channelID *id.ID, pubKey ed25519.PublicKey, unmute bool)
}

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

type ExtensionBuilder func(e EventModel, m Manager,
	me cryptoChannel.PrivateIdentity) ([]ExtensionMessageHandler, error)

type ExtensionMessageHandler interface {
	// GetType registers the message type that this handler is for. All messages
	// of this type will be passed through this handler.
	GetType() MessageType

	// GetProperties returns debugging and pre-filtering information.
	//
	// Parameters:
	//   - name - A name that is included in log messages for debugging.
	//   - userSpace - If true, then normal user messages will be passed to the
	//     handler, otherwise it is dropped.
	//   - adminSpace - If true, then admin messages will be passed to the
	//     handler, otherwise it is dropped.
	//   - mutedSpace - If true, then muted user messages will be passed to the
	//     handler, otherwise it is dropped.
	//
	// userSpace or adminSpace must be true or all messages will be ignored
	GetProperties() (name string, userSpace, adminSpace, mutedSpace bool)

	// Handle is called when the message is actually received.
	//
	// Parameters:
	//	 - channelID - ID of the channel that the message belongs to.
	//	 - messageID - Unique ID of the message. May not be present if this
	//	   user is the sender.
	//   - messageType - The type of the message. It will always be the same as
	//     GetType.
	//   - nickname - Sender's chosen username. It will be "admin" if it is sent
	//     by a channel administrator.
	//	 - content - The decrypted contents of the payload. This is the actual
	//	   message contents sent from the sender.
	//   - encryptedPayload - Encrypted contents of the received format.Message,
	//     which is the encrypted channels.ChannelMessage. It is used for some
	//     specific admin interactions.
	//   - pubKey - The Ed25519 public key of the sender.
	//   - dmToken - An optional token that the sender may add to allow any
	//     recipient to message them directly.
	//   - codeset - Codename generation version.
	//   - timestamp - Time the message was sent according to the sender.
	//   - originatingTimestamp - The time the mix round the message was
	//     originally sent on started.
	//   - lease - How long the message should persist. The behavior of the
	//     lease is subject to what the extension author wants.
	//   - originatingRound - The ID of the round the message was originally
	//     sent on.
	//   - round - All known details of the round the message was sent on.
	//   - status - The current state of the message, if it is queued to send,
	//     has been sent, and if it has been delivered. Unless this client is
	//     the sender, it will always be Delivered.
	//   - fromAdmin - Indicates if the message came from the channel admin.
	//   - hidden - Designation that the message should not be shown.
	Handle(channelID *id.ID, messageID message.ID, messageType MessageType,
		nickname string, content, encryptedPayload []byte,
		pubKey ed25519.PublicKey, dmToken uint32, codeset uint8, timestamp,
		originatingTimestamp time.Time, lease time.Duration,
		originatingRound id.Round, round rounds.Round, status SentStatus,
		fromAdmin, hidden bool) uint64

	// GetNotificationTags is called to get the asymmetric and symmetric allow
	// lists for the given channel at the specified level that are appended to
	// the [NotificationFilter].
	GetNotificationTags(channelID *id.ID, level NotificationLevel) (
		asymmetric, symmetric AllowLists)
}

type Manager interface {

	// GenerateChannel creates a new channel with the user as the admin and
	// returns the broadcast.Channel object. This function only create a channel
	// and does not join it.
	//
	// The private key is saved to storage and can be accessed with
	// ExportChannelAdminKey.
	//
	// Parameters:
	//   - name - The name of the new channel. The name must be between 3 and 24
	//     characters inclusive. It can only include upper and lowercase Unicode
	//     letters, digits 0 through 9, and underscores (_). It cannot be
	//     changed once a channel is created.
	//   - description - The description of a channel. The description is
	//     optional but cannot be longer than 144 characters and can include all
	//     Unicode characters. It cannot be changed once a channel is created.
	//   - privacyLevel - The broadcast.PrivacyLevel of the channel.
	GenerateChannel(
		name, description string, privacyLevel cryptoBroadcast.PrivacyLevel) (
		*cryptoBroadcast.Channel, error)

	// JoinChannel joins the given channel. It will return the error
	// ChannelAlreadyExistsErr if the channel has already been joined.
	JoinChannel(channel *cryptoBroadcast.Channel) error

	// LeaveChannel leaves the given channel. It will return the error
	// ChannelDoesNotExistsErr if the channel was not previously joined.
	LeaveChannel(channelID *id.ID) error

	// EnableDirectMessages enables the token for direct messaging for this
	// channel.
	EnableDirectMessages(chId *id.ID) error

	// DisableDirectMessages removes the token for direct messaging for a
	// given channel.
	DisableDirectMessages(chId *id.ID) error

	// AreDMsEnabled returns the status of DMs for a given channel;
	// returns true if DMs are enabled.
	AreDMsEnabled(chId *id.ID) bool

	// ReplayChannel replays all messages from the channel within the network's
	// memory (~3 weeks) over the event model. It does this by wiping the
	// underlying state tracking for message pickup for the channel, causing all
	// messages to be re-retrieved from the network.
	//
	// Returns the error ChannelDoesNotExistsErr if the channel was not
	// previously joined.
	ReplayChannel(channelID *id.ID) error

	// GetChannels returns the IDs of all channels that have been joined.
	GetChannels() []*id.ID

	// GetChannel returns the underlying cryptographic structure for a given
	// channel.
	//
	// Returns the error ChannelDoesNotExistsErr if the channel was not
	// previously joined.
	GetChannel(channelID *id.ID) (*cryptoBroadcast.Channel, error)

	// SendGeneric is used to send a raw message over a channel. 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 minimum.
	//
	// The meaning of validUntil depends on the use case.
	//
	// Set tracked to true if the message should be tracked in the sendTracker,
	// which allows messages to be shown locally before they are received on the
	// network. In general, all messages that will be displayed to the user
	// should be tracked while all actions should not be. More technically, any
	// messageType that corresponds to a handler that does not return a unique
	// ID (i.e., always returns 0) cannot be tracked, or it will cause errors.
	SendGeneric(channelID *id.ID, messageType MessageType, msg []byte,
		validUntil time.Duration, tracked bool, params cmix.CMIXParams,
		pingsMap map[PingType][]ed25519.PublicKey) (
		message.ID, rounds.Round, ephemeral.Id, error)

	// SendMessage is used to send a formatted message over a channel.
	//
	// 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 798 bytes at minimum.
	//
	// The message will auto delete validUntil after the round it is sent in,
	// lasting forever if ValidForever is used.
	SendMessage(channelID *id.ID, msg string, validUntil time.Duration,
		params cmix.CMIXParams, pings []ed25519.PublicKey) (
		message.ID, rounds.Round, ephemeral.Id, error)

	// SendReply is used to send a formatted message over a channel.
	//
	// 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 766 bytes at minimum.
	//
	// 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.
	//
	// The message will auto delete validUntil after the round it is sent in,
	// lasting forever if ValidForever is used.
	SendReply(channelID *id.ID, msg string, replyTo message.ID,
		validUntil time.Duration, params cmix.CMIXParams,
		pings []ed25519.PublicKey) (
		message.ID, rounds.Round, ephemeral.Id, error)

	// SendReaction is used to send a reaction to a message over a channel. 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.
	//
	// The message will auto delete validUntil after the round it is sent in,
	// lasting forever if ValidForever is used.
	SendReaction(channelID *id.ID, reaction string, reactTo message.ID,
		validUntil time.Duration, params cmix.CMIXParams) (
		message.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(channelID *id.ID, validUntil time.Duration,
		params cmix.CMIXParams) (message.ID, rounds.Round, ephemeral.Id, error)

	// SendInvite is used to send to a channel (invited) an invitation to another
	// channel (invitee).
	//
	// If the channel ID for the invitee channel is not recognized by the Manager,
	// then an error will be returned.
	//
	// See [Manager.SendGeneric] for details on payload size limitations and
	// elaboration of pings.
	SendInvite(channelID *id.ID, msg string, inviteTo *cryptoBroadcast.Channel,
		host string,
		validUntil time.Duration, params cmix.CMIXParams,
		pings []ed25519.PublicKey) (
		message.ID, rounds.Round, ephemeral.Id, error)

	// SendAdminGeneric is used to send a raw message over a channel encrypted
	// with admin keys, identifying it as sent by the admin. 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. The message must be at most 510 bytes long.
	//
	// If the user is not an admin of the channel (i.e. does not have a private
	// key for the channel saved to storage), then the error NotAnAdminErr is
	// returned.
	//
	// Set tracked to true if the message should be tracked in the sendTracker,
	// which allows messages to be shown locally before they are received on the
	// network. In general, all messages that will be displayed to the user
	// should be tracked while all actions should not be. More technically, any
	// messageType that corresponds to a handler that does not return a unique
	// ID (i.e., always returns 0) cannot be tracked, or it will cause errors.
	SendAdminGeneric(channelID *id.ID, messageType MessageType, msg []byte,
		validUntil time.Duration, tracked bool, params cmix.CMIXParams) (
		message.ID, rounds.Round, ephemeral.Id, error)

	// DeleteMessage deletes the targeted message from storage. Users may delete
	// their own messages but only the channel admin can delete other user's
	// messages. If the user is not an admin of the channel or if they are not
	// the sender of the targetMessage, then the error NotAnAdminErr is
	// returned.
	//
	// Clients will drop the deletion if they do not recognize the target
	// message.
	DeleteMessage(channelID *id.ID, targetMessage message.ID,
		params cmix.CMIXParams) (
		message.ID, rounds.Round, ephemeral.Id, error)

	// PinMessage pins the target message to the top of a channel view for all
	// users in the specified channel. Only the channel admin can pin user
	// messages; if the user is not an admin of the channel, then the error
	// NotAnAdminErr is returned.
	//
	// If undoAction is true, then the targeted message is unpinned. validUntil
	// is the time the message will be pinned for; set this to ValidForever to
	// pin indefinitely. validUntil is ignored if undoAction is true.
	//
	// Clients will drop the pin if they do not recognize the target message.
	PinMessage(channelID *id.ID, targetMessage message.ID,
		undoAction bool, validUntil time.Duration, params cmix.CMIXParams) (
		message.ID, rounds.Round, ephemeral.Id, error)

	// MuteUser is used to mute a user in a channel. Muting a user will cause
	// all future messages from the user being dropped on reception. Muted users
	// are also unable to send messages. Only the channel admin can mute a user;
	// if the user is not an admin of the channel, then the error NotAnAdminErr
	// is returned.
	//
	// If undoAction is true, then the targeted user will be unmuted. validUntil
	// is the time the user will be muted for; set this to ValidForever to mute
	// the user indefinitely. validUntil is ignored if undoAction is true.
	MuteUser(channelID *id.ID, mutedUser ed25519.PublicKey, undoAction bool,
		validUntil time.Duration, params cmix.CMIXParams) (
		message.ID, rounds.Round, ephemeral.Id, error)

	// GetIdentity returns the public identity of the user associated with this
	// channel manager.
	GetIdentity() cryptoChannel.Identity

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

	// GetStorageTag returns the tag where this manager is stored. To be used
	// when loading the manager. The storage tag is derived from the public key.
	GetStorageTag() string

	// RegisterReceiveHandler registers a listener for non-default message types
	// so that they can be processed by modules. It is important that such
	// modules collective up with the event model implementation.
	//
	// There can only be one handler per message type; the error
	// MessageTypeAlreadyRegistered will be returned on multiple registrations
	// of the same type.
	//
	// To create a ReceiveMessageHandler, use NewReceiveMessageHandler.
	RegisterReceiveHandler(
		messageType MessageType, handler *ReceiveMessageHandler) error

	// SetNickname sets the nickname in a channel after checking that the
	// nickname is valid using [IsNicknameValid].
	SetNickname(nickname string, channelID *id.ID) error

	// DeleteNickname removes the nickname for a given channel. The name will
	// revert back to the codename for this channel instead.
	DeleteNickname(channelID *id.ID) error

	// GetNickname returns the nickname for the given channel, if it exists.
	GetNickname(channelID *id.ID) (nickname string, exists bool)

	// Muted returns true if the user is currently muted in the given channel.
	Muted(channelID *id.ID) bool

	// GetMutedUsers returns the list of the public keys for each muted user in
	// the channel. If there are no muted user or if the channel does not exist,
	// an empty list is returned.
	GetMutedUsers(channelID *id.ID) []ed25519.PublicKey

	// GetNotificationLevel returns the notification level for the given channel.
	GetNotificationLevel(channelID *id.ID) (NotificationLevel, error)

	// GetNotificationStatus returns the notification status for the given channel.
	GetNotificationStatus(channelID *id.ID) (clientNotif.NotificationState, error)

	// SetMobileNotificationsLevel sets the notification level for the given
	// channel. The [NotificationLevel] dictates the type of notifications
	// received and the status controls weather the notification is push or
	// in-app. If muted, both the level and status must be set to mute.
	//
	// To use push notifications, a token must be registered with the
	// notification manager. Note, when enabling push notifications, information
	// may be shared with third parties (i.e., Firebase and Google's Palantir)
	// and may represent a security risk to the user.
	SetMobileNotificationsLevel(channelID *id.ID, level NotificationLevel,
		status clientNotif.NotificationState) error

	// IsChannelAdmin returns true if the user is an admin of the channel.
	IsChannelAdmin(channelID *id.ID) bool

	// ExportChannelAdminKey gets the private key for the given channel ID,
	// encrypts it with the provided encryptionPassword, and exports it into a
	// portable format. Returns an error if the user is not an admin of the
	// channel.
	//
	// This key can be provided to other users in a channel to grant them admin
	// access using ImportChannelAdminKey.
	//
	// The private key is encrypted using a key generated from the password
	// using Argon2. Each call to ExportChannelAdminKey produces a different
	// encrypted packet regardless if the same password is used for the same
	// channel. It cannot be determined which channel the payload is for nor
	// that two payloads are for the same channel.
	//
	// The passwords between each call are not related. They can be the same or
	// different with no adverse impact on the security properties.
	ExportChannelAdminKey(
		channelID *id.ID, encryptionPassword string) ([]byte, error)

	// VerifyChannelAdminKey verifies that the encrypted private key can be
	// decrypted and that it matches the expected channel. Returns false if
	// private key does not belong to the given channel.
	//
	// Returns the error WrongPasswordErr for an invalid password. Returns the
	// error ChannelDoesNotExistsErr if the channel has not already been joined.
	VerifyChannelAdminKey(
		channelID *id.ID, encryptionPassword string, encryptedPrivKey []byte) (
		bool, error)

	// ImportChannelAdminKey decrypts and imports the given encrypted private
	// key and grants the user admin access to the channel the private key
	// belongs to. Returns an error if the private key cannot be decrypted or if
	// the private key is for the wrong channel.
	//
	// Returns the error WrongPasswordErr for an invalid password. Returns the
	// error ChannelDoesNotExistsErr if the channel has not already been joined.
	// Returns the error WrongPrivateKeyErr if the private key does not belong
	// to the channel.
	ImportChannelAdminKey(channelID *id.ID, encryptionPassword string,
		encryptedPrivKey []byte) error

	// DeleteChannelAdminKey deletes the private key for the given channel.
	//
	// CAUTION: This will remove admin access. This cannot be undone. If the
	// private key is deleted, it cannot be recovered and the channel can never
	// have another admin.
	DeleteChannelAdminKey(channelID *id.ID) error
}

type MessageType uint16

type MessageTypeReceiveMessage func(channelID *id.ID, messageID message.ID,
	messageType MessageType, nickname string, content, encryptedPayload []byte,
	pubKey ed25519.PublicKey, dmToken uint32, codeset uint8, timestamp,
	originatingTimestamp time.Time, lease time.Duration,
	originatingRound id.Round, round rounds.Round, status SentStatus, fromAdmin,
	hidden bool) uint64

type ModelMessage struct {
	UUID            uint64            `json:"uuid"`
	Nickname        string            `json:"nickname"`
	MessageID       message.ID        `json:"messageID"`
	ChannelID       *id.ID            `json:"channelID"`
	ParentMessageID message.ID        `json:"parentMessageID"`
	Timestamp       time.Time         `json:"timestamp"`
	Lease           time.Duration     `json:"lease"`
	Status          SentStatus        `json:"status"`
	Hidden          bool              `json:"hidden"`
	Pinned          bool              `json:"pinned"`
	Content         []byte            `json:"content"`
	Type            MessageType       `json:"type"`
	Round           id.Round          `json:"round"`
	PubKey          ed25519.PublicKey `json:"pubKey"`
	CodesetVersion  uint8             `json:"codesetVersion"`
	DmToken         uint32            `json:"dmToken"`
}

type NameService interface {
	// GetUsername returns the username.
	GetUsername() string

	// GetChannelValidationSignature returns the validation signature and the
	// time it was signed.
	GetChannelValidationSignature() ([]byte, time.Time)

	// GetChannelPubkey returns the user's public key.
	GetChannelPubkey() ed25519.PublicKey

	// SignChannelMessage returns the signature of the given message.
	SignChannelMessage(message []byte) (signature []byte, err error)

	// ValidateChannelMessage validates that a received channel message's
	// username lease is signed by the NameService.
	ValidateChannelMessage(username string, lease time.Time,
		pubKey ed25519.PublicKey, authorIDSignature []byte) bool
}

type NotificationCallback func(nfs []NotificationFilter,
	changedNotificationStates []NotificationState,
	deletedNotificationStates []*id.ID, maxState clientNotif.NotificationState)

type NotificationFilter struct {
	Identifier []byte `json:"identifier"`

	// ChannelID is the ID that the filter belongs to.
	ChannelID *id.ID `json:"channelID"`

	// Tags is a list of tags to match against.
	Tags []string `json:"tags"`

	AllowLists `json:"allowLists"`
}

type NotificationInfo struct {
	Status   bool   `json:"status"`
	Metadata []byte `json:"metadata"`
}

type NotificationLevel uint8

type NotificationReport struct {
	// Channel is the channel ID that the notification is for.
	Channel *id.ID `json:"channel"`

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

	// PingType describes the type of ping. If it is empty, then it is a generic
	// ping.
	PingType PingType `json:"pingType,omitempty"`
}

type NotificationState struct {
	ChannelID *id.ID                        `json:"channelID"`
	Level     NotificationLevel             `json:"level"`
	Status    clientNotif.NotificationState `json:"status"`
}

type NotificationsManager interface {
	Set(toBeNotifiedOn *id.ID, group string, metadata []byte,
		status clientNotif.NotificationState) error
	Get(toBeNotifiedOn *id.ID) (status clientNotif.NotificationState,
		metadata []byte, group string, exists bool)
	Delete(toBeNotifiedOn *id.ID) error
	RegisterUpdateCallback(group string, nu clientNotif.Update)
}

type PingType string

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

type ReplayActionFunc func(channelID *id.ID, encryptedPayload []byte)

type SentStatus uint8

type UiCallbacks interface {
	// NicknameUpdate is called when your nickname changes due to a
	// change on a remote.
	NicknameUpdate(channelId *id.ID, nickname string, exists bool)

	// NotificationUpdate is a callback that is called any time a notification
	// level changes. It is also called when loading, adding, and deleting
	// channels.
	//
	// It returns a slice of [NotificationFilter] for all channels with
	// notifications enabled. The [NotificationFilter] is used to determine
	// which notifications from the notification server belong to the caller.
	//
	// It also returns a map of all channel notification states that have
	// changed and all that have been deleted. The maxState is the global state
	// set for notifications.
	NotificationUpdate(nfs []NotificationFilter,
		changedNotificationStates []NotificationState,
		deletedNotificationStates []*id.ID, maxState clientNotif.NotificationState)

	// AdminKeysUpdate is a callback be called when a channel's admin key is
	// added or removed. (See [Manager.ImportChannelAdminKey] or
	// [Manager.DeleteChannelAdminKey]).
	AdminKeysUpdate(chID *id.ID, isAdmin bool)

	// DmTokenUpdate is a callback be called when a channel's dm token state is
	// changed
	DmTokenUpdate(chID *id.ID, sendToken bool)

	// ChannelUpdate is called any time the user joins or leaves a channel.
	// deleted is false when joining and true when leaving.
	ChannelUpdate(channelID *id.ID, deleted bool)

	// MessageReceived is called any time a new message is received or an
	// existing message is modified. update is ture when the message is
	// modified. It is false when receiving a new message.
	MessageReceived(uuid int64, channelID *id.ID, update bool)

	// UserMuted is called every time a user is muted or unmuted.
	UserMuted(channelID *id.ID, pubKey ed25519.PublicKey, unmute bool)

	// MessageDeleted is called every time a message is deleted.
	MessageDeleted(messageID message.ID)
}

type UpdateActionFn func() (uint64, error)

type UpdateFromUuidFunc func(uuid uint64, messageID *message.ID,
	timestamp *time.Time, round *rounds.Round, pinned, hidden *bool,
	status *SentStatus) error

type UserMessage struct {

	// Message contains the contents of the message. This is typically what the
	// end-user has submitted to the channel. This is a serialization of the
	// ChannelMessage.
	Message []byte `protobuf:"bytes,1,opt,name=Message,proto3" json:"Message,omitempty"`
	// Signature is the signature proving this message has been sent by the
	// owner of this user's public key.
	//
	//	Signature = Sig(User_ECCPublicKey, Message)
	Signature []byte `protobuf:"bytes,3,opt,name=Signature,proto3" json:"Signature,omitempty"`
	// ECCPublicKey is the user's EC Public key. This is provided by the
	// network.
	ECCPublicKey []byte `protobuf:"bytes,5,opt,name=ECCPublicKey,proto3" json:"ECCPublicKey,omitempty"`
	// contains filtered or unexported fields
}