federation

type Client struct {
	HTTP       *http.Client
	ServerName string
	UserAgent  string
	Key        *SigningKey

	ResponseSizeLimit int64
}

type EDU = json.RawMessage

type GetQueryKeysResponse struct {
	ServerKeys []*ServerKeyResponse `json:"server_keys"`
}

type InMemoryCache struct {
	MinKeyRefetchDelay time.Duration
	// contains filtered or unexported fields
}

type KeyCache interface {
	StoreKeys(*ServerKeyResponse)
	StoreFetchError(serverName string, err error)
	ShouldReQuery(serverName string) bool
	LoadKeys(serverName string) (*ServerKeyResponse, error)
}

type KeyServer struct {
	KeyProvider     ServerKeyProvider
	Version         ServerVersion
	WellKnownTarget string
	OtherKeys       KeyCache
}

type KeyURLPath []any

type OldVerifyKey struct {
	Key       id.SigningKey      `json:"key"`
	ExpiredTS jsontime.UnixMilli `json:"expired_ts"`
}

type PDU = json.RawMessage

type PDUProcessingResult struct {
	Error string `json:"error,omitempty"`
}

type PostQueryKeysResponse struct {
	ServerKeys map[string]*ServerKeyResponse `json:"server_keys"`
}

type QueryKeysCriteria struct {
	MinimumValidUntilTS jsontime.UnixMilli `json:"minimum_valid_until_ts"`
}

type QueryKeysResponse struct {
	ServerKeys []*ServerKeyResponse `json:"server_keys"`
}

type ReqBackfill struct {
	ServerName   string
	RoomID       id.RoomID
	Limit        int
	BackfillFrom []id.EventID
}

type ReqGetMissingEvents struct {
	ServerName     string       `json:"-"`
	RoomID         id.RoomID    `json:"-"`
	EarliestEvents []id.EventID `json:"earliest_events"`
	LatestEvents   []id.EventID `json:"latest_events"`
	Limit          int          `json:"limit,omitempty"`
	MinDepth       int          `json:"min_depth,omitempty"`
}

type ReqMakeJoin struct {
	RoomID            id.RoomID
	UserID            id.UserID
	Via               string
	SupportedVersions []id.RoomVersion
}

type ReqMakeKnock = ReqMakeJoin

type ReqMakeLeave struct {
	RoomID id.RoomID
	UserID id.UserID
	Via    string
}

type ReqQueryKeys struct {
	ServerKeys map[string]map[id.KeyID]QueryKeysCriteria `json:"server_keys"`
}

type ReqSendInvite struct {
	RoomID          id.RoomID      `json:"-"`
	UserID          id.UserID      `json:"-"`
	Event           PDU            `json:"event"`
	InviteRoomState []PDU          `json:"invite_room_state"`
	RoomVersion     id.RoomVersion `json:"room_version"`
}

type ReqSendJoin struct {
	RoomID      id.RoomID
	EventID     id.EventID
	OmitMembers bool
	Event       PDU
	Via         string
}

type ReqSendKnock struct {
	RoomID  id.RoomID
	EventID id.EventID
	Event   PDU
	Via     string
}

type ReqSendLeave struct {
	RoomID  id.RoomID
	EventID id.EventID
	Event   PDU
	Via     string
}

type ReqSendTransaction struct {
	Destination string `json:"destination"`
	TxnID       string `json:"-"`

	Origin         string             `json:"origin"`
	OriginServerTS jsontime.UnixMilli `json:"origin_server_ts"`
	PDUs           []PDU              `json:"pdus"`
	EDUs           []EDU              `json:"edus,omitempty"`
}

type RequestParams struct {
	ServerName   string
	Method       string
	Path         mautrix.PrefixableURLPath
	Query        url.Values
	Authenticate bool
	RequestJSON  any

	ResponseJSON any
	DontReadBody bool
}

type ResolutionCache interface {
	StoreResolution(*ResolvedServerName)
	// LoadResolution loads a resolved server name from the cache.
	// Expired entries MUST NOT be returned.
	LoadResolution(serverName string) (*ResolvedServerName, error)
}

type ResolveServerNameOpts struct {
	HTTPClient *http.Client
	DNSClient  *net.Resolver
}

type ResolvedServerName struct {
	ServerName string    `json:"server_name"`
	HostHeader string    `json:"host_header"`
	IPPort     []string  `json:"ip_port"`
	Expires    time.Time `json:"expires"`
}

type RespBackfill struct {
	Origin         string             `json:"origin"`
	OriginServerTS jsontime.UnixMilli `json:"origin_server_ts"`
	PDUs           []PDU              `json:"pdus"`
}

type RespGetEventAuthChain struct {
	AuthChain []PDU `json:"auth_chain"`
}

type RespGetMissingEvents struct {
	Events []PDU `json:"events"`
}

type RespGetState struct {
	AuthChain []PDU `json:"auth_chain"`
	PDUs      []PDU `json:"pdus"`
}

type RespGetStateIDs struct {
	AuthChain []id.EventID `json:"auth_chain_ids"`
	PDUs      []id.EventID `json:"pdu_ids"`
}

type RespMakeJoin struct {
	RoomVersion id.RoomVersion `json:"room_version"`
	Event       PDU            `json:"event"`
}

type RespMakeKnock = RespMakeJoin

type RespMakeLeave = RespMakeJoin

type RespOpenIDUserInfo struct {
	Sub id.UserID `json:"sub"`
}

type RespSendInvite struct {
	Event PDU `json:"event"`
}

type RespSendJoin struct {
	AuthChain      []PDU    `json:"auth_chain"`
	Event          PDU      `json:"event"`
	MembersOmitted bool     `json:"members_omitted"`
	ServersInRoom  []string `json:"servers_in_room"`
	State          []PDU    `json:"state"`
}

type RespSendKnock struct {
	KnockRoomState []PDU `json:"knock_room_state"`
}

type RespSendTransaction struct {
	PDUs map[id.EventID]PDUProcessingResult `json:"pdus"`
}

type RespServerVersion struct {
	Server ServerVersion `json:"server"`
}

type RespWellKnown struct {
	Server string `json:"m.server"`
}

type ServerAuth struct {
	Keys           KeyCache
	Client         *Client
	GetDestination func(XMatrixAuth) string
	MaxBodySize    int64
	// contains filtered or unexported fields
}

type ServerKeyProvider interface {
	Get(r *http.Request) (serverName string, key *SigningKey)
}

type ServerKeyResponse struct {
	ServerName    string                         `json:"server_name"`
	VerifyKeys    map[id.KeyID]ServerVerifyKey   `json:"verify_keys"`
	OldVerifyKeys map[id.KeyID]OldVerifyKey      `json:"old_verify_keys,omitempty"`
	Signatures    map[string]map[id.KeyID]string `json:"signatures,omitempty"`
	ValidUntilTS  jsontime.UnixMilli             `json:"valid_until_ts"`

	Raw json.RawMessage `json:"-"`
}

type ServerResolvingTransport struct {
	ResolveOpts *ResolveServerNameOpts
	Transport   *http.Transport
	Dialer      *net.Dialer
	// contains filtered or unexported fields
}

type ServerVerifyKey struct {
	Key id.SigningKey `json:"key"`
}

type ServerVersion struct {
	Name    string `json:"name"`
	Version string `json:"version"`
}

type SigningKey struct {
	ID   id.KeyID
	Pub  id.SigningKey
	Priv ed25519.PrivateKey
}

type StaticServerKey struct {
	ServerName string
	Key        *SigningKey
}

type URLPath []any

type XMatrixAuth struct {
	Origin      string
	Destination string
	KeyID       id.KeyID
	Signature   string
}