bridgev2

type APNsPushConfig struct {
	BundleID string `json:"bundle_id"`
}

type Avatar struct {
	ID     networkid.AvatarID
	Get    func(ctx context.Context) ([]byte, error)
	Remove bool

	// For pre-uploaded avatars, the MXC URI and hash can be provided directly
	MXC  id.ContentURIString
	Hash [32]byte
}

type BackfillMessage struct {
	*ConvertedMessage
	Sender      EventSender
	ID          networkid.MessageID
	TxnID       networkid.TransactionID
	Timestamp   time.Time
	StreamOrder int64
	Reactions   []*BackfillReaction

	ShouldBackfillThread bool
	LastThreadMessage    networkid.MessageID
}

type BackfillReaction struct {
	// Optional part of the message that the reaction targets.
	// If nil, the reaction targets the first part of the message.
	TargetPart *networkid.PartID
	// Optional timestamp for the reaction.
	// If unset, the reaction will have a fake timestamp that is slightly after the message timestamp.
	Timestamp time.Time

	Sender       EventSender
	EmojiID      networkid.EmojiID
	Emoji        string
	ExtraContent map[string]any
	DBMetadata   any
}

type BackfillingNetworkAPI interface {
	NetworkAPI
	// FetchMessages returns a batch of messages to backfill in a portal room.
	// For details on the input and output, see the documentation of [FetchMessagesParams] and [FetchMessagesResponse].
	FetchMessages(ctx context.Context, fetchParams FetchMessagesParams) (*FetchMessagesResponse, error)
}

type BackfillingNetworkAPIWithLimits interface {
	BackfillingNetworkAPI
	// GetBackfillMaxBatchCount is called before a backfill task is executed to determine the maximum number of batches
	// that should be backfilled. Return values less than 0 are treated as unlimited.
	GetBackfillMaxBatchCount(ctx context.Context, portal *Portal, task *database.BackfillTask) int
}

type BackgroundSyncingNetworkAPI interface {
	NetworkAPI
	// ConnectBackground is called in place of Connect for background resyncs.
	// The client should connect to the remote network, handle pending messages, and then disconnect.
	// This call should block until the entire sync is complete and the client is disconnected.
	ConnectBackground(ctx context.Context, params *ConnectBackgroundParams) error
}

type Bridge struct {
	ID  networkid.BridgeID
	DB  *database.Database
	Log zerolog.Logger

	Matrix   MatrixConnector
	Bot      MatrixAPI
	Network  NetworkConnector
	Commands CommandProcessor
	Config   *bridgeconfig.BridgeConfig

	DisappearLoop *DisappearLoop

	Background          bool
	ExternallyManagedDB bool

	BackgroundCtx context.Context
	// contains filtered or unexported fields
}

type BridgeName struct {
	// The displayname of the network, e.g. `Discord`
	DisplayName string `json:"displayname"`
	// The URL to the website of the network, e.g. `https://discord.com`
	NetworkURL string `json:"network_url"`
	// The icon of the network as a mxc:// URI
	NetworkIcon id.ContentURIString `json:"network_icon"`
	// An identifier uniquely identifying the network, e.g. `discord`
	NetworkID string `json:"network_id"`
	// An identifier uniquely identifying the bridge software.
	// The Go import path is a good choice here (e.g. github.com/octocat/discordbridge)
	BeeperBridgeType string `json:"beeper_bridge_type"`
	// The default appservice port to use in the example config, defaults to 8080 if unset
	// Official mautrix bridges will use ports defined in https://mau.fi/ports
	DefaultPort uint16 `json:"default_port,omitempty"`
	// The default command prefix to use in the example config, defaults to NetworkID if unset. Must include the ! prefix.
	DefaultCommandPrefix string `json:"default_command_prefix,omitempty"`
}

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

type CallbackError struct {
	Type    string
	Wrapped error
}

type ChatInfo struct {
	Name   *string
	Topic  *string
	Avatar *Avatar

	Members  *ChatMemberList
	JoinRule *event.JoinRulesEventContent

	Type      *database.RoomType
	Disappear *database.DisappearingSetting
	ParentID  *networkid.PortalID

	UserLocal      *UserLocalPortalInfo
	MessageRequest *bool
	CanBackfill    bool

	ExcludeChangesFromTimeline bool

	ExtraUpdates ExtraUpdater[*Portal]
}

type ChatInfoChange struct {
	// The chat info that changed. Any fields that did not change can be left as nil.
	ChatInfo *ChatInfo
	// A list of member changes.
	// This list should only include changes, not the whole member list.
	// To resync the whole list, use the field inside ChatInfo.
	MemberChanges *ChatMemberList
}

type ChatMember struct {
	EventSender
	Membership event.Membership
	// Per-room nickname for the user. Not yet used.
	Nickname *string
	// The power level to set for the user when syncing power levels.
	PowerLevel *int
	// Optional user info to sync the ghost user while updating membership.
	UserInfo *UserInfo
	// The user who sent the membership change (user who invited/kicked/banned this user).
	// Not yet used. Not applicable if Membership is join or knock.
	MemberSender EventSender
	// Extra fields to include in the member event.
	MemberEventExtra map[string]any
	// The expected previous membership. If this doesn't match, the change is ignored.
	PrevMembership event.Membership
}

type ChatMemberList struct {
	// Whether this is the full member list.
	// If true, any extra members not listed here will be removed from the portal.
	IsFull bool
	// Should the bridge call IsThisUser for every member in the list?
	// This should be used when SenderLogin can't be filled accurately.
	CheckAllLogins bool
	// Should any changes have the `com.beeper.exclude_from_timeline` flag set by default?
	// This is recommended for syncs with non-real-time changes.
	// Real-time changes (e.g. a user joining) should not set this flag set.
	ExcludeChangesFromTimeline bool

	// The total number of members in the chat, regardless of how many of those members are included in MemberMap.
	TotalMemberCount int

	// For DM portals, the ID of the recipient user.
	// This field is optional and will be automatically filled from MemberMap if there are only 2 entries in the map.
	OtherUserID networkid.UserID

	// Deprecated: Use MemberMap instead to avoid duplicate entries
	Members     []ChatMember
	MemberMap   ChatMemberMap
	PowerLevels *PowerLevelOverrides
}

type ChatMemberMap map[networkid.UserID]ChatMember

type ChatViewingNetworkAPI interface {
	NetworkAPI
	// HandleMatrixViewingChat is called when the user opens a portal room.
	// This will never be called by the standard appservice connector,
	// as Matrix doesn't have any standard way of signaling chat open status.
	// Clients are expected to call this every 5 seconds. There is no signal for closing a chat.
	HandleMatrixViewingChat(ctx context.Context, msg *MatrixViewingChat) error
}

type CommandProcessor interface {
	Handle(ctx context.Context, roomID id.RoomID, eventID id.EventID, user *User, message string, replyTo id.EventID)
}

type ConfigValidatingNetwork interface {
	NetworkConnector
	ValidateConfig() error
}

type ConnectBackgroundParams struct {
	// RawData is the raw data in the push that triggered the background connection.
	RawData json.RawMessage
	// ExtraData is the data returned by [PushParsingNetwork.ParsePushNotification].
	// It's only present for native pushes. Relayed pushes will only have the raw data.
	ExtraData any
}

type ContactListingNetworkAPI interface {
	NetworkAPI
	GetContactList(ctx context.Context) ([]*ResolveIdentifierResponse, error)
}

type ConvertedEdit struct {
	ModifiedParts []*ConvertedEditPart
	DeletedParts  []*database.Message
	// Warning: added parts will be sent at the end of the room.
	// If other messages have been sent after the message being edited,
	// these new parts will not be next to the existing parts.
	AddedParts *ConvertedMessage
}

type ConvertedEditPart struct {
	Part *database.Message

	Type event.Type
	// The Content and Extra fields will be put inside `m.new_content` automatically.
	// SetEdit must NOT be called by the network connector.
	Content *event.MessageEventContent
	Extra   map[string]any
	// TopLevelExtra can be used to specify custom fields at the top level of the content rather than inside `m.new_content`.
	TopLevelExtra map[string]any
	// NewMentions can be used to specify new mentions that should ping the users again.
	// Mentions inside the edited content will not ping.
	NewMentions *event.Mentions

	DontBridge bool
}

type ConvertedMessage struct {
	ReplyTo *networkid.MessageOptionalPartID
	// Optional additional info about the reply. This is only used when backfilling messages
	// on Beeper, where replies may target messages that haven't been bridged yet.
	// Standard Matrix servers can't backwards backfill, so these are never used.
	ReplyToRoom  networkid.PortalKey
	ReplyToUser  networkid.UserID
	ReplyToLogin networkid.UserLoginID

	ThreadRoot *networkid.MessageID
	Parts      []*ConvertedMessagePart
	Disappear  database.DisappearingSetting
}

type ConvertedMessagePart struct {
	ID         networkid.PartID
	Type       event.Type
	Content    *event.MessageEventContent
	Extra      map[string]any
	DBMetadata any
	DontBridge bool
}

type CreateChatFailedParticipant struct {
	Reason          string         `json:"reason"`
	InviteEventType string         `json:"invite_event_type,omitempty"`
	InviteContent   *event.Content `json:"invite_content,omitempty"`

	UserMXID   id.UserID `json:"user_mxid,omitempty"`
	DMRoomMXID id.RoomID `json:"dm_room_mxid,omitempty"`
}

type CreateChatResponse struct {
	PortalKey networkid.PortalKey
	// Portal and PortalInfo are not required, the caller will fetch them automatically based on PortalKey if necessary.
	Portal     *Portal
	PortalInfo *ChatInfo
	// If a start DM request (CreateChatWithGhost or ResolveIdentifier) returns the DM to a different user,
	// this field should have the user ID of said different user.
	DMRedirectedTo networkid.UserID

	FailedParticipants map[networkid.UserID]*CreateChatFailedParticipant
}

type CredentialExportingNetworkAPI interface {
	NetworkAPI
	ExportCredentials(ctx context.Context) any
}

type DBUpgradeError struct {
	Err     error
	Section string
}

type DeleteChatHandlingNetworkAPI interface {
	NetworkAPI
	// HandleMatrixDeleteChat is called when the user explicitly deletes a chat.
	HandleMatrixDeleteChat(ctx context.Context, msg *MatrixDeleteChat) error
}

type DeleteOpts struct {
	LogoutRemote     bool
	DontCleanupRooms bool
	BlockingCleanup  bool
	// contains filtered or unexported fields
}

type DirectMediableNetwork interface {
	NetworkConnector
	SetUseDirectMedia()
	Download(ctx context.Context, mediaID networkid.MediaID, params map[string]string) (mediaproxy.GetMediaResponse, error)
}

type DirectNotificationData struct {
	Portal    *Portal
	Sender    *Ghost
	MessageID networkid.MessageID
	Message   string

	FormattedNotification string
	FormattedTitle        string
}

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

type DisappearTimerChangingNetworkAPI interface {
	NetworkAPI
	// HandleMatrixDisappearingTimer is called when the disappearing timer of a portal room is changed.
	// This method should update the Disappear field of the Portal with the new timer and return true
	// if the change was successful. If the change is not successful, then the field should not be updated.
	HandleMatrixDisappearingTimer(ctx context.Context, msg *MatrixDisappearingTimer) (bool, error)
}

type EditHandlingNetworkAPI interface {
	NetworkAPI
	// HandleMatrixEdit is called when a previously bridged message is edited in a portal room.
	// The central bridge module will save the [*database.Message] after this function returns,
	// so the network connector is allowed to mutate the provided object.
	HandleMatrixEdit(ctx context.Context, msg *MatrixEdit) error
}

type EnsureJoinedParams struct {
	Via []string
}

type EventHandlingResult struct {
	Success bool
	Ignored bool
	Queued  bool

	SkipStateEcho bool

	// Error is an optional reason for failure. It is not required, Success may be false even without a specific error.
	Error error
	// Whether the Error should be sent as a MSS event.
	SendMSS bool

	// EventID from the network
	EventID id.EventID
	// Stream order from the network
	StreamOrder int64
}

type EventSender struct {
	// If IsFromMe is true, the UserLogin who the event was received through is used as the sender.
	// Double puppeting will be used if available.
	IsFromMe bool
	// SenderLogin is the ID of the UserLogin who sent the event. This may be different from the
	// login the event was received through. It is used to ensure double puppeting can still be
	// used even if the event is received through another login.
	SenderLogin networkid.UserLoginID
	// Sender is the remote user ID of the user who sent the event.
	// For new events, this will not be used for double puppeting.
	//
	// However, in the member list, [ChatMemberList.CheckAllLogins] can be specified to go through every login
	// and call [NetworkAPI.IsThisUser] to check if this ID belongs to that login. This method is not recommended,
	// it is better to fill the IsFromMe and SenderLogin fields appropriately.
	Sender networkid.UserID

	// ForceDMUser can be set if the event should be sent as the DM user even if the Sender is different.
	// This only applies in DM rooms where [database.Portal.OtherUserID] is set and is ignored if IsFromMe is true.
	// A warning will be logged if the sender is overridden due to this flag.
	ForceDMUser bool
}

type ExtraUpdater[T any] func(context.Context, T) bool

type FCMPushConfig struct {
	SenderID string `json:"sender_id"`
}

type FetchMessagesParams struct {
	// The portal to fetch messages in. Always present.
	Portal *Portal
	// When fetching messages inside a thread, the ID of the thread.
	ThreadRoot networkid.MessageID
	// Whether to fetch new messages instead of old ones.
	Forward bool
	// The oldest known message in the thread or the portal. If Forward is true, this is the newest known message instead.
	// If the portal doesn't have any bridged messages, this will be nil.
	AnchorMessage *database.Message
	// The cursor returned by the previous call to FetchMessages with the same portal and thread root.
	// This will not be present in Forward calls.
	Cursor networkid.PaginationCursor
	// The preferred number of messages to return. The returned batch can be bigger or smaller
	// without any side effects, but the network connector should aim for this number.
	Count int

	// When a forward backfill is triggered by a [RemoteChatResyncBackfillBundle], this will contain
	// the bundled data returned by the event. It can be used as an optimization to avoid fetching
	// messages that were already provided by the remote network, while still supporting fetching
	// more messages if the limit is higher.
	BundledData any

	// When the messages are being fetched for a queued backfill, this is the task object.
	Task *database.BackfillTask
}

type FetchMessagesResponse struct {
	// The messages to backfill. Messages should always be sorted in chronological order (oldest to newest).
	Messages []*BackfillMessage
	// The next cursor to use for fetching more messages.
	Cursor networkid.PaginationCursor
	// Whether there are more messages that can be backfilled.
	// This field is required. If it is false, FetchMessages will not be called again.
	HasMore bool
	// Whether the batch contains new messages rather than old ones.
	// Cursor, HasMore and the progress fields will be ignored when this is present.
	Forward bool
	// When sending forward backfill (or the first batch in a room), this field can be set
	// to mark the messages as read immediately after backfilling.
	MarkRead bool

	// Should the bridge check each message against the database to ensure it's not a duplicate before bridging?
	// By default, the bridge will only drop messages that are older than the last bridged message for forward backfills,
	// or newer than the first for backward.
	AggressiveDeduplication bool

	// Approximate backfill progress as a number between 0 and 1.
	ApproxProgress float64
	// Approximate number of messages remaining that can be backfilled.
	ApproxRemainingCount int
	// Approximate total number of messages in the chat.
	ApproxTotalCount int

	// An optional function that is called after the backfill batch has been sent.
	CompleteCallback func()
}

type FileStreamCallback func(file io.Writer) (*FileStreamResult, error)

type FileStreamResult struct {
	// ReplacementFile is the path to a new file that replaces the original file provided to the callback.
	// Providing a replacement file is only allowed if the requireFile flag was set for the UploadMediaStream call.
	ReplacementFile string
	// FileName is the name of the file to be specified when uploading to the server.
	// This should be the same as the file name that will be included in the Matrix event (body or filename field).
	// If the file gets encrypted, this field will be ignored.
	FileName string
	// MimeType is the type of field to be specified when uploading to the server.
	// This should be the same as the mime type that will be included in the Matrix event (info -> mimetype field).
	// If the file gets encrypted, this field will be replaced with application/octet-stream.
	MimeType string
}

type Ghost struct {
	*database.Ghost
	Bridge *Bridge
	Log    zerolog.Logger
	Intent MatrixAPI
}

type GhostDMCreatingNetworkAPI interface {
	IdentifierResolvingNetworkAPI
	// CreateChatWithGhost may be called instead of [IdentifierResolvingNetworkAPI.ResolveIdentifier]
	// when starting a chat with an internal user identifier that has been pre-validated using
	// [IdentifierValidatingNetwork.ValidateUserID]. If this is not implemented, ResolveIdentifier
	// will be used instead (by stringifying the ghost ID).
	CreateChatWithGhost(ctx context.Context, ghost *Ghost) (*CreateChatResponse, error)
}

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

type GroupCreateParams struct {
	Type string `json:"type,omitempty"`

	Username string `json:"username,omitempty"`
	// Clients may also provide MXIDs here, but provisionutil will normalize them, so bridges only need to handle network IDs
	Participants []networkid.UserID   `json:"participants,omitempty"`
	Parent       *networkid.PortalKey `json:"parent,omitempty"`

	Name      *event.RoomNameEventContent    `json:"name,omitempty"`
	Avatar    *event.RoomAvatarEventContent  `json:"avatar,omitempty"`
	Topic     *event.TopicEventContent       `json:"topic,omitempty"`
	Disappear *event.BeeperDisappearingTimer `json:"disappear,omitempty"`

	// An existing room ID to bridge to. If unset, a new room will be created.
	RoomID id.RoomID `json:"room_id,omitempty"`
}

type GroupCreatingNetworkAPI interface {
	IdentifierResolvingNetworkAPI
	CreateGroup(ctx context.Context, params *GroupCreateParams) (*CreateChatResponse, error)
}

type GroupFieldCapability struct {
	// Is setting this field allowed at all in the create request?
	// Even if false, the network connector should attempt to set the metadata after group creation,
	// as the allowed flag can't be enforced properly when creating a group for an existing Matrix room.
	Allowed bool `json:"allowed"`
	// Is setting this field mandatory for the creation to succeed?
	Required bool `json:"required,omitempty"`
	// The minimum/maximum length of the field, if applicable.
	// For members, length means the number of members excluding the creator.
	MinLength int `json:"min_length,omitempty"`
	MaxLength int `json:"max_length,omitempty"`

	// Only for the disappear field: allowed disappearing settings
	DisappearSettings *event.DisappearingTimerCapability `json:"settings,omitempty"`

	// This can be used to tell provisionutil not to call ValidateUserID on each participant.
	// It only meant to allow hacks where ResolveIdentifier returns a fake ID that isn't actually valid for MXIDs.
	SkipIdentifierValidation bool `json:"-"`
}

type GroupTypeCapabilities struct {
	TypeDescription string `json:"type_description"`

	Name         GroupFieldCapability `json:"name"`
	Username     GroupFieldCapability `json:"username"`
	Avatar       GroupFieldCapability `json:"avatar"`
	Topic        GroupFieldCapability `json:"topic"`
	Disappear    GroupFieldCapability `json:"disappear"`
	Participants GroupFieldCapability `json:"participants"`
	Parent       GroupFieldCapability `json:"parent"`
}

type IProvisioningAPI interface {
	GetRouter() *http.ServeMux
	GetUser(r *http.Request) *User
}

type IdentifierResolvingNetworkAPI interface {
	NetworkAPI
	// ResolveIdentifier is called when the user wants to start a new chat.
	// This can happen via the `resolve-identifier` or `start-chat` bridge bot commands,
	// or the corresponding provisioning API endpoints.
	ResolveIdentifier(ctx context.Context, identifier string, createChat bool) (*ResolveIdentifierResponse, error)
}

type IdentifierValidatingNetwork interface {
	NetworkConnector
	ValidateUserID(id networkid.UserID) bool
}

type LoginCompleteParams struct {
	UserLoginID networkid.UserLoginID `json:"user_login_id"`
	UserLogin   *UserLogin            `json:"-"`
}

type LoginCookieField struct {
	// The key in the map that is submitted to the connector.
	ID       string `json:"id"`
	Required bool   `json:"required"`
	// The sources that can be used to acquire the field value. Only one of these needs to be used.
	Sources []LoginCookieFieldSource `json:"sources"`
	// A regex pattern that the client can use to validate value client-side.
	Pattern string `json:"pattern,omitempty"`
}

type LoginCookieFieldSource struct {
	// The type of source.
	Type LoginCookieFieldSourceType `json:"type"`
	// The name of the field. The exact meaning depends on the type of source.
	// Cookie:         cookie name
	// Local storage:  key in local storage
	// Request header: header name
	// Request body:   field name inside body after it's parsed (as JSON or multipart form data)
	// Special:        a namespaced identifier that clients can implement special handling for
	Name string `json:"name"`

	// For request header & body types, a regex matching request URLs where the value can be extracted from.
	RequestURLRegex string `json:"request_url_regex,omitempty"`
	// For cookie types, the domain the cookie is present on.
	CookieDomain string `json:"cookie_domain,omitempty"`
}

type LoginCookieFieldSourceType string

type LoginCookiesParams struct {
	URL       string `json:"url"`
	UserAgent string `json:"user_agent,omitempty"`

	// The fields that are needed for this cookie login.
	Fields []LoginCookieField `json:"fields"`
	// A JavaScript snippet that can extract some or all of the fields.
	// The snippet will evaluate to a promise that resolves when the relevant fields are found.
	// Fields that are not present in the promise result must be extracted another way.
	ExtractJS string `json:"extract_js,omitempty"`
	// A regex pattern that the URL should match before the client closes the webview.
	//
	// The client may submit the login if the user closes the webview after all cookies are collected
	// even if this URL is not reached, but it should only automatically close the webview after
	// both cookies and the URL match.
	WaitForURLPattern string `json:"wait_for_url_pattern,omitempty"`
}

type LoginDisplayAndWaitParams struct {
	// The type of thing to display (QR, emoji or text code)
	Type LoginDisplayType `json:"type"`
	// The thing to display (raw data for QR, unicode emoji for emoji, plain string for code, omitted for nothing)
	Data string `json:"data,omitempty"`
	// An image containing the thing to display. If present, this is recommended over using data directly.
	// For emojis, the URL to the canonical image representation of the emoji
	ImageURL string `json:"image_url,omitempty"`
}

type LoginDisplayType string

type LoginFlow struct {
	Name        string `json:"name"`
	Description string `json:"description"`
	ID          string `json:"id"`
}

type LoginInputDataField struct {
	// The type of input field as a hint for the client.
	Type LoginInputFieldType `json:"type"`
	// The ID of the field to be used as the key in the map that is submitted to the connector.
	ID string `json:"id"`
	// The name of the field shown to the user.
	Name string `json:"name"`
	// The description of the field shown to the user.
	Description string `json:"description"`
	// A default value that the client can pre-fill the field with.
	DefaultValue string `json:"default_value,omitempty"`
	// A regex pattern that the client can use to validate input client-side.
	Pattern string `json:"pattern,omitempty"`
	// For fields of type select, the valid options.
	// Pattern may also be filled with a regex that matches the same options.
	Options []string `json:"options,omitempty"`
	// A function that validates the input and optionally cleans it up before it's submitted to the connector.
	Validate func(string) (string, error) `json:"-"`
}

type LoginInputFieldType string

type LoginProcess interface {
	// Start starts the process and returns the first step.
	//
	// For example, a network using QR login may connect to the network, fetch a QR code,
	// and return a DisplayAndWait-type step.
	//
	// This will only ever be called once.
	Start(ctx context.Context) (*LoginStep, error)
	// Cancel stops the login process and cleans up any resources.
	// No other methods will be called after cancel.
	//
	// Cancel will not be called if any other method returned an error:
	// errors are always treated as fatal and the process is assumed to be automatically cancelled.
	Cancel()
}

type LoginProcessCookies interface {
	LoginProcess
	SubmitCookies(ctx context.Context, cookies map[string]string) (*LoginStep, error)
}

type LoginProcessDisplayAndWait interface {
	LoginProcess
	Wait(ctx context.Context) (*LoginStep, error)
}

type LoginProcessUserInput interface {
	LoginProcess
	SubmitUserInput(ctx context.Context, input map[string]string) (*LoginStep, error)
}

type LoginProcessWithOverride interface {
	LoginProcess
	// StartWithOverride starts the process with the intent of re-authenticating an existing login.
	//
	// The call to this is mutually exclusive with the call to the default Start method.
	//
	// The user login being overridden will still be logged out automatically
	// in case the complete step returns a different login.
	StartWithOverride(ctx context.Context, override *UserLogin) (*LoginStep, error)
}

type LoginStep struct {
	// The type of login step
	Type LoginStepType `json:"type"`
	// A unique ID for this step. The ID should be same for every login using the same flow,
	// but it should be different for different bridges and step types.
	//
	// For example, Telegram's QR scan followed by a 2-factor password
	// might use the IDs `fi.mau.telegram.qr` and `fi.mau.telegram.2fa_password`.
	StepID string `json:"step_id"`
	// Instructions contains human-readable instructions for completing the login step.
	Instructions string `json:"instructions"`

	DisplayAndWaitParams *LoginDisplayAndWaitParams `json:"display_and_wait,omitempty"`
	CookiesParams        *LoginCookiesParams        `json:"cookies,omitempty"`
	UserInputParams      *LoginUserInputParams      `json:"user_input,omitempty"`
	CompleteParams       *LoginCompleteParams       `json:"complete,omitempty"`
}

type LoginStepType string

type LoginSubmit struct {
}

type LoginUserInputParams struct {
	// The fields that the user needs to fill in.
	Fields []LoginInputDataField `json:"fields"`
}

type MarkAsDMMatrixAPI interface {
	MatrixAPI
	MarkAsDM(ctx context.Context, roomID id.RoomID, otherUser id.UserID) error
}

type MarkedUnreadHandlingNetworkAPI interface {
	NetworkAPI
	HandleMarkedUnread(ctx context.Context, msg *MatrixMarkedUnread) error
}

type MatrixAPI interface {
	GetMXID() id.UserID
	IsDoublePuppet() bool

	SendMessage(ctx context.Context, roomID id.RoomID, eventType event.Type, content *event.Content, extra *MatrixSendExtra) (*mautrix.RespSendEvent, error)
	SendState(ctx context.Context, roomID id.RoomID, eventType event.Type, stateKey string, content *event.Content, ts time.Time) (*mautrix.RespSendEvent, error)
	MarkRead(ctx context.Context, roomID id.RoomID, eventID id.EventID, ts time.Time) error
	MarkUnread(ctx context.Context, roomID id.RoomID, unread bool) error
	MarkTyping(ctx context.Context, roomID id.RoomID, typingType TypingType, timeout time.Duration) error
	DownloadMedia(ctx context.Context, uri id.ContentURIString, file *event.EncryptedFileInfo) ([]byte, error)
	DownloadMediaToFile(ctx context.Context, uri id.ContentURIString, file *event.EncryptedFileInfo, writable bool, callback func(*os.File) error) error
	UploadMedia(ctx context.Context, roomID id.RoomID, data []byte, fileName, mimeType string) (url id.ContentURIString, file *event.EncryptedFileInfo, err error)
	UploadMediaStream(ctx context.Context, roomID id.RoomID, size int64, requireFile bool, cb FileStreamCallback) (url id.ContentURIString, file *event.EncryptedFileInfo, err error)

	SetDisplayName(ctx context.Context, name string) error
	SetAvatarURL(ctx context.Context, avatarURL id.ContentURIString) error
	SetExtraProfileMeta(ctx context.Context, data any) error

	CreateRoom(ctx context.Context, req *mautrix.ReqCreateRoom) (id.RoomID, error)
	DeleteRoom(ctx context.Context, roomID id.RoomID, puppetsOnly bool) error
	EnsureJoined(ctx context.Context, roomID id.RoomID, params ...EnsureJoinedParams) error
	EnsureInvited(ctx context.Context, roomID id.RoomID, userID id.UserID) error

	TagRoom(ctx context.Context, roomID id.RoomID, tag event.RoomTag, isTagged bool) error
	MuteRoom(ctx context.Context, roomID id.RoomID, until time.Time) error

	GetEvent(ctx context.Context, roomID id.RoomID, eventID id.EventID) (*event.Event, error)
}

type MatrixAcceptMessageRequest = MatrixEventBase[*event.BeeperAcceptMessageRequestEventContent]

type MatrixCapabilities struct {
	AutoJoinInvites       bool
	BatchSending          bool
	ArbitraryMemberChange bool
}

type MatrixConnector interface {
	Init(*Bridge)
	Start(ctx context.Context) error
	PreStop()
	Stop()

	GetCapabilities() *MatrixCapabilities

	ParseGhostMXID(userID id.UserID) (networkid.UserID, bool)
	GhostIntent(userID networkid.UserID) MatrixAPI
	NewUserIntent(ctx context.Context, userID id.UserID, accessToken string) (MatrixAPI, string, error)
	BotIntent() MatrixAPI

	SendBridgeStatus(ctx context.Context, state *status.BridgeState) error
	SendMessageStatus(ctx context.Context, status *MessageStatus, evt *MessageStatusEventInfo)

	GenerateContentURI(ctx context.Context, mediaID networkid.MediaID) (id.ContentURIString, error)

	GetPowerLevels(ctx context.Context, roomID id.RoomID) (*event.PowerLevelsEventContent, error)
	GetMembers(ctx context.Context, roomID id.RoomID) (map[id.UserID]*event.MemberEventContent, error)
	GetMemberInfo(ctx context.Context, roomID id.RoomID, userID id.UserID) (*event.MemberEventContent, error)
	GetDisplayname(ctx context.Context, userID id.UserID) string

	BatchSend(ctx context.Context, roomID id.RoomID, req *mautrix.ReqBeeperBatchSend, extras []*MatrixSendExtra) (*mautrix.RespBeeperBatchSend, error)
	GenerateDeterministicRoomID(portalKey networkid.PortalKey) id.RoomID
	GenerateDeterministicEventID(roomID id.RoomID, portalKey networkid.PortalKey, messageID networkid.MessageID, partID networkid.PartID) id.EventID
	GenerateReactionEventID(roomID id.RoomID, targetMessage *database.Message, sender networkid.UserID, emojiID networkid.EmojiID) id.EventID

	ServerName() string
}

type MatrixConnectorWithAnalytics interface {
	MatrixConnector
	TrackAnalytics(userID id.UserID, event string, properties map[string]any)
}

type MatrixConnectorWithArbitraryRoomState interface {
	MatrixConnector
	GetStateEvent(ctx context.Context, roomID id.RoomID, eventType event.Type, stateKey string) (*event.Event, error)
}

type MatrixConnectorWithBridgeIdentifier interface {
	MatrixConnector
	GetUniqueBridgeID() string
}

type MatrixConnectorWithHTTPSettings interface {
	MatrixConnector
	GetHTTPClientSettings() exhttp.ClientSettings
}

type MatrixConnectorWithNameDisambiguation interface {
	MatrixConnector
	IsConfusableName(ctx context.Context, roomID id.RoomID, userID id.UserID, name string) ([]id.UserID, error)
}

type MatrixConnectorWithNotifications interface {
	MatrixConnector
	DisplayNotification(ctx context.Context, data *DirectNotificationData)
}

type MatrixConnectorWithPostRoomBridgeHandling interface {
	MatrixConnector
	HandleNewlyBridgedRoom(ctx context.Context, roomID id.RoomID) error
}

type MatrixConnectorWithProvisioning interface {
	MatrixConnector
	GetProvisioning() IProvisioningAPI
}

type MatrixConnectorWithPublicMedia interface {
	MatrixConnector
	GetPublicMediaAddress(contentURI id.ContentURIString) string
	GetPublicMediaAddressForEvent(ctx context.Context, evt *event.MessageEventContent) (string, error)
}

type MatrixConnectorWithServer interface {
	MatrixConnector
	GetPublicAddress() string
	GetRouter() *http.ServeMux
}

type MatrixConnectorWithURLPreviews interface {
	MatrixConnector
	GetURLPreview(ctx context.Context, url string) (*event.LinkPreview, error)
}

type MatrixDeleteChat = MatrixEventBase[*event.BeeperChatDeleteEventContent]

type MatrixDisappearingTimer = MatrixRoomMeta[*event.BeeperDisappearingTimer]

type MatrixEdit struct {
	MatrixEventBase[*event.MessageEventContent]
	EditTarget *database.Message
}

type MatrixEventBase[ContentType any] struct {
	// The raw event being bridged.
	Event *event.Event
	// The parsed content struct of the event. Custom fields can be found in Event.Content.Raw.
	Content ContentType
	// The room where the event happened.
	Portal *Portal

	// The original sender user ID. Only present in case the event is being relayed (and Sender is not the same user).
	OrigSender *OrigSender

	InputTransactionID networkid.RawTransactionID
}

type MatrixMarkedUnread = MatrixRoomMeta[*event.MarkedUnreadEventContent]

type MatrixMembershipChange struct {
	MatrixRoomMeta[*event.MemberEventContent]
	Target GhostOrUserLogin
	Type   MembershipChangeType
}

type MatrixMembershipResult struct {
	RedirectTo networkid.UserID
}

type MatrixMessage struct {
	MatrixEventBase[*event.MessageEventContent]
	ThreadRoot *database.Message
	ReplyTo    *database.Message
	// contains filtered or unexported fields
}

type MatrixMessageRemove struct {
	MatrixEventBase[*event.RedactionEventContent]
	TargetMessage *database.Message
}

type MatrixMessageResponse struct {
	DB          *database.Message
	StreamOrder int64
	// If Pending is set, the bridge will not save the provided message to the database.
	// This should only be used if AddPendingToSave has been called.
	Pending bool
	// If RemovePending is set, the bridge will remove the provided transaction ID from pending messages
	// after saving the provided message to the database. This should be used with AddPendingToIgnore.
	RemovePending networkid.TransactionID
	// An optional function that is called after the message is saved to the database.
	// Will not be called if the message is not saved for some reason.
	PostSave func(context.Context, *database.Message)
}

type MatrixMute = MatrixRoomMeta[*event.BeeperMuteEventContent]

type MatrixPollStart struct {
	MatrixMessage
	Content *event.PollStartEventContent
}

type MatrixPollVote struct {
	MatrixMessage
	VoteTo  *database.Message
	Content *event.PollResponseEventContent
}

type MatrixPowerLevelChange struct {
	MatrixRoomMeta[*event.PowerLevelsEventContent]
	Users         map[id.UserID]*UserPowerLevelChange
	Events        map[string]*SinglePowerLevelChange
	UsersDefault  *SinglePowerLevelChange
	EventsDefault *SinglePowerLevelChange
	StateDefault  *SinglePowerLevelChange
	Invite        *SinglePowerLevelChange
	Kick          *SinglePowerLevelChange
	Ban           *SinglePowerLevelChange
	Redact        *SinglePowerLevelChange
}

type MatrixReaction struct {
	MatrixEventBase[*event.ReactionEventContent]
	TargetMessage *database.Message
	PreHandleResp *MatrixReactionPreResponse

	// When EmojiID is blank and there's already an existing reaction, this is the old reaction that is being overridden.
	ReactionToOverride *database.Reaction
	// When MaxReactions is >0 in the pre-response, this is the list of previous reactions that should be preserved.
	ExistingReactionsToKeep []*database.Reaction
}

type MatrixReactionPreResponse struct {
	SenderID     networkid.UserID
	EmojiID      networkid.EmojiID
	Emoji        string
	MaxReactions int
}

type MatrixReactionRemove struct {
	MatrixEventBase[*event.RedactionEventContent]
	TargetReaction *database.Reaction
}

type MatrixReadReceipt struct {
	Portal *Portal
	// The event ID that the receipt is targeting
	EventID id.EventID
	// The exact message that was read. This may be nil if the event ID isn't a message.
	ExactMessage *database.Message
	// The timestamp that the user has read up to. This is either the timestamp of the message
	// (if one is present) or the timestamp of the receipt.
	ReadUpTo time.Time
	// The ReadUpTo timestamp of the previous message
	LastRead time.Time
	// The receipt metadata.
	Receipt event.ReadReceipt
	// Whether the receipt is implicit, i.e. triggered by an incoming timeline event rather than an explicit receipt.
	Implicit bool
}

type MatrixRoomAvatar = MatrixRoomMeta[*event.RoomAvatarEventContent]

type MatrixRoomMeta[ContentType any] struct {
	MatrixEventBase[ContentType]
	PrevContent    ContentType
	IsStateRequest bool
}

type MatrixRoomName = MatrixRoomMeta[*event.RoomNameEventContent]

type MatrixRoomTag = MatrixRoomMeta[*event.TagEventContent]

type MatrixRoomTopic = MatrixRoomMeta[*event.TopicEventContent]

type MatrixSendExtra struct {
	Timestamp    time.Time
	MessageMeta  *database.Message
	ReactionMeta *database.Reaction
	StreamOrder  int64
	PartIndex    int
}

type MatrixTyping struct {
	Portal   *Portal
	IsTyping bool
	Type     TypingType
}

type MatrixViewingChat struct {
	// The portal that the user is viewing. This will be nil when the user switches to a chat from a different bridge.
	Portal *Portal
}

type MaxFileSizeingNetwork interface {
	NetworkConnector
	SetMaxFileSize(maxSize int64)
}

type MembershipChangeType struct {
	From   event.Membership
	To     event.Membership
	IsSelf bool
}

type MembershipHandlingNetworkAPI interface {
	NetworkAPI
	HandleMatrixMembership(ctx context.Context, msg *MatrixMembershipChange) (*MatrixMembershipResult, error)
}

type MessageRequestAcceptingNetworkAPI interface {
	NetworkAPI
	// HandleMatrixAcceptMessageRequest is called when the user accepts a message request.
	HandleMatrixAcceptMessageRequest(ctx context.Context, msg *MatrixAcceptMessageRequest) error
}

type MessageStatus struct {
	Step     status.MessageCheckpointStep
	RetryNum int

	Status        event.MessageStatus
	ErrorReason   event.MessageStatusReason
	DeliveredTo   []id.UserID
	InternalError error  // Internal error to be tracked in message checkpoints
	Message       string // Human-readable message shown to users

	ErrorAsMessage bool
	IsCertain      bool
	SendNotice     bool
	DisableMSS     bool
}

type MessageStatusEventInfo struct {
	RoomID        id.RoomID
	TransactionID string
	SourceEventID id.EventID
	NewEventID    id.EventID
	EventType     event.Type
	MessageType   event.MessageType
	Sender        id.UserID
	ThreadRoot    id.EventID
	StreamOrder   int64

	IsSourceEventDoublePuppeted bool
}

type MuteHandlingNetworkAPI interface {
	NetworkAPI
	HandleMute(ctx context.Context, msg *MatrixMute) error
}

type NetworkAPI interface {
	// Connect is called to actually connect to the remote network.
	// If there's no persistent connection, this may just check access token validity, or even do nothing at all.
	// This method isn't allowed to return errors, because any connection errors should be sent
	// using the bridge state mechanism (UserLogin.BridgeState.Send)
	Connect(ctx context.Context)
	// Disconnect should disconnect from the remote network.
	// A clean disconnection is preferred, but it should not take too long.
	Disconnect()
	// IsLoggedIn should return whether the access tokens in this NetworkAPI are valid.
	// This should not do any IO operations, it should only return cached data which is updated elsewhere.
	IsLoggedIn() bool
	// LogoutRemote should invalidate the access tokens in this NetworkAPI if possible
	// and disconnect from the remote network.
	LogoutRemote(ctx context.Context)

	// IsThisUser should return whether the given remote network user ID is the same as this login.
	// This is used when the bridge wants to convert a user login ID to a user ID.
	IsThisUser(ctx context.Context, userID networkid.UserID) bool
	// GetChatInfo returns info for a given chat. Any fields that are nil will be ignored and not processed at all,
	// while empty strings will change the relevant value in the room to be an empty string.
	// For example, a nil name will mean the room name is not changed, while an empty string name will remove the name.
	GetChatInfo(ctx context.Context, portal *Portal) (*ChatInfo, error)
	// GetUserInfo returns info for a given user. Like chat info, fields can be nil to skip them.
	GetUserInfo(ctx context.Context, ghost *Ghost) (*UserInfo, error)
	// GetCapabilities returns the bridging capabilities in a given room.
	// This can simply return a static list if the remote network has no per-chat capability differences,
	// but all calls will include the portal, because some networks do have per-chat differences.
	GetCapabilities(ctx context.Context, portal *Portal) *event.RoomFeatures

	// HandleMatrixMessage is called when a message is sent from Matrix in an existing portal room.
	// This function should convert the message as appropriate, send it over to the remote network,
	// and return the info so the central bridge can store it in the database.
	//
	// This is only called for normal non-edit messages. For other types of events, see the optional extra interfaces (`XHandlingNetworkAPI`).
	HandleMatrixMessage(ctx context.Context, msg *MatrixMessage) (message *MatrixMessageResponse, err error)
}

type NetworkConnector interface {
	// Init is called when the bridge is initialized. The connector should store the bridge instance for later use.
	// This should not do any network calls or other blocking operations.
	Init(*Bridge)
	// Start is called when the bridge is starting.
	// The connector should do any non-user-specific startup actions necessary.
	// User logins will be loaded separately, so the connector should not load them here.
	Start(context.Context) error

	// GetName returns the name of the bridge and some additional metadata,
	// which is used to fill `m.bridge` events among other things.
	//
	// The first call happens *before* the config is loaded, because the data here is also used to
	// fill parts of the example config (like the default username template and bot localpart).
	// The output can still be adjusted based on config variables, but the function must have
	// default values when called without a config.
	GetName() BridgeName
	// GetDBMetaTypes returns struct types that are used to store connector-specific metadata in various tables.
	// All fields are optional. If a field isn't provided, then the corresponding table will have no custom metadata.
	// This will be called before Init, it should have a hardcoded response.
	GetDBMetaTypes() database.MetaTypes
	// GetCapabilities returns the general capabilities of the network connector.
	// Note that most capabilities are scoped to rooms and are returned by [NetworkAPI.GetCapabilities] instead.
	GetCapabilities() *NetworkGeneralCapabilities
	// GetConfig returns all the parts of the network connector's config file. Specifically:
	// - example: a string containing an example config file
	// - data: an interface to unmarshal the actual config into
	// - upgrader: a config upgrader to ensure all fields are present and to do any migrations from old configs
	GetConfig() (example string, data any, upgrader configupgrade.Upgrader)

	// LoadUserLogin is called when a UserLogin is loaded from the database in order to fill the [UserLogin.Client] field.
	//
	// This is called within the bridge's global cache lock, so it must not do any slow operations,
	// such as connecting to the network. Instead, connecting should happen when [NetworkAPI.Connect] is called later.
	LoadUserLogin(ctx context.Context, login *UserLogin) error

	// GetLoginFlows returns a list of login flows that the network supports.
	GetLoginFlows() []LoginFlow
	// CreateLogin is called when a user wants to log in to the network.
	//
	// This should generally not do any work, it should just return a LoginProcess that remembers
	// the user and will execute the requested flow. The actual work should start when [LoginProcess.Start] is called.
	CreateLogin(ctx context.Context, user *User, flowID string) (LoginProcess, error)

	// GetBridgeInfoVersion returns version numbers for bridge info and room capabilities respectively.
	// When the versions change, the bridge will automatically resend bridge info to all rooms.
	GetBridgeInfoVersion() (info, capabilities int)
}

type NetworkGeneralCapabilities struct {
	// Does the network connector support disappearing messages?
	// This flag enables the message disappearing loop in the bridge.
	DisappearingMessages bool
	// Should the bridge re-request user info on incoming messages even if the ghost already has info?
	// By default, info is only requested for ghosts with no name, and other updating is left to events.
	AggressiveUpdateInfo bool
	// Should the bridge call HandleMatrixReadReceipt with fake data when receiving a new message?
	// This should be enabled if the network requires each message to be marked as read independently,
	// and doesn't automatically do it when sending a message.
	ImplicitReadReceipts bool
	// If the bridge uses the pending message mechanism ([MatrixMessage.AddPendingToSave])
	// to handle asynchronous message responses, this field can be set to enable
	// automatic timeout errors in case the asynchronous response never arrives.
	OutgoingMessageTimeouts *OutgoingTimeoutConfig
	// Capabilities related to the provisioning API.
	Provisioning ProvisioningCapabilities
}

type NetworkResettingNetwork interface {
	NetworkConnector
	// ResetHTTPTransport should recreate the HTTP client used by the bridge.
	// It should refetch settings from the Matrix connector using GetHTTPClientSettings if applicable.
	ResetHTTPTransport()
	// ResetNetworkConnections should forcefully disconnect and restart any persistent network connections.
	// ResetHTTPTransport will usually be called before this, so resetting the transport is not necessary here.
	ResetNetworkConnections()
}

type NewLoginParams struct {
	LoadUserLogin     func(context.Context, *UserLogin) error
	DeleteOnConflict  bool
	DontReuseExisting bool
}

type OrigSender struct {
	User   *User
	UserID id.UserID

	RequiresDisambiguation bool
	DisambiguatedName      string
	FormattedName          string
	PerMessageProfile      event.BeeperPerMessageProfile

	event.MemberEventContent
}

type OutgoingTimeoutConfig struct {
	CheckInterval time.Duration
	NoEchoTimeout time.Duration
	NoEchoMessage string
	NoAckTimeout  time.Duration
	NoAckMessage  string
}

type PersonalFilteringCustomizingNetworkAPI interface {
	NetworkAPI
	CustomizePersonalFilteringSpace(req *mautrix.ReqCreateRoom)
}

type PollHandlingNetworkAPI interface {
	NetworkAPI
	HandleMatrixPollStart(ctx context.Context, msg *MatrixPollStart) (*MatrixMessageResponse, error)
	HandleMatrixPollVote(ctx context.Context, msg *MatrixPollVote) (*MatrixMessageResponse, error)
}

type Portal struct {
	*database.Portal
	Bridge *Bridge
	Log    zerolog.Logger
	Parent *Portal
	Relay  *UserLogin

	RoomCreated *exsync.Event
	// contains filtered or unexported fields
}

type PortalBridgeInfoFillingNetwork interface {
	NetworkConnector
	FillPortalBridgeInfo(portal *Portal, content *event.BridgeEventContent)
}

type PortalInternals Portal

type PowerLevelHandlingNetworkAPI interface {
	NetworkAPI
	HandleMatrixPowerLevels(ctx context.Context, msg *MatrixPowerLevelChange) (bool, error)
}

type PowerLevelOverrides struct {
	Events        map[event.Type]int
	UsersDefault  *int
	EventsDefault *int
	StateDefault  *int
	Invite        *int
	Kick          *int
	Ban           *int
	Redact        *int

	Custom func(*event.PowerLevelsEventContent) bool
}

type ProvisioningCapabilities struct {
	ResolveIdentifier ResolveIdentifierCapabilities    `json:"resolve_identifier"`
	GroupCreation     map[string]GroupTypeCapabilities `json:"group_creation"`
}

type PushConfig struct {
	Web  *WebPushConfig  `json:"web,omitempty"`
	FCM  *FCMPushConfig  `json:"fcm,omitempty"`
	APNs *APNsPushConfig `json:"apns,omitempty"`
	// If Native is true, it means the network supports registering for pushes
	// that are delivered directly to the app without the use of a push relay.
	Native bool `json:"native,omitempty"`
}

type PushParsingNetwork interface {
	NetworkConnector

	// ParsePushNotification is called when a native push is received.
	// It must return the corresponding user login ID to wake up, plus optionally data to pass to the wakeup call.
	ParsePushNotification(ctx context.Context, data json.RawMessage) (networkid.UserLoginID, any, error)
}