package module
Version: v0.7.1 Latest Latest

This package is not in the latest version of its module.

Go to latest
Published: Aug 21, 2020 License: MPL-2.0 Imports: 16 Imported by: 107




A Golang Matrix framework.

This project is based on matrix-org/gomatrix. The original project is licensed under Apache 2.0.

This project contains modules that are licensed under Apache 2.0:



Package mautrix implements the Matrix Client-Server API.

Specification can be found at



View Source
const (
	AuthTypePassword  = "m.login.password"
	AuthTypeReCAPTCHA = "m.login.recaptcha"
	AuthTypeOAuth2    = "m.login.oauth2"
	AuthTypeSSO       = "m.login.sso"
	AuthTypeEmail     = ""
	AuthTypeMSISDN    = "m.login.msisdn"
	AuthTypeToken     = "m.login.token"
	AuthTypeDummy     = "m.login.dummy"
View Source
const (
	IdentifierTypeUser       = ""
	IdentifierTypeThirdParty = ""
	IdentifierTypePhone      = ""
View Source
const Version = "v0.7.1"


This section is empty.


This section is empty.


type AuthType added in v0.7.1

type AuthType string

type BaseAuthData added in v0.7.1

type BaseAuthData struct {
	Type    AuthType `json:"type"`
	Session string   `json:"session"`

type Client

type Client struct {
	HomeserverURL *url.URL     // The base homeserver URL
	Prefix        URLPath      // The API prefix eg '/_matrix/client/r0'
	UserID        id.UserID    // The user ID of the client. Used for forming HTTP paths which use the client's user ID.
	DeviceID      id.DeviceID  // The device ID of the client.
	AccessToken   string       // The access_token for the client.
	UserAgent     string       // The value for the User-Agent header
	Client        *http.Client // The underlying HTTP client which will be used to make HTTP requests.
	Syncer        Syncer       // The thing which can process /sync responses
	Store         Storer       // The thing which can store rooms/tokens/ids
	Logger        Logger
	SyncPresence  event.Presence

	// The ?user_id= query parameter for application services. This must be set *prior* to calling a method. If this is empty,
	// no user_id parameter will be sent.
	// See
	AppServiceUserID id.UserID
	// contains filtered or unexported fields

Client represents a Matrix client.

func NewClient

func NewClient(homeserverURL string, userID id.UserID, accessToken string) (*Client, error)

NewClient creates a new Matrix Client ready for syncing

func (*Client) AddTag

func (cli *Client) AddTag(roomID id.RoomID, tag string, order float64) (err error)

func (*Client) BanUser

func (cli *Client) BanUser(roomID id.RoomID, req *ReqBanUser) (resp *RespBanUser, err error)

BanUser bans a user from a room. See

func (*Client) BuildBaseURL

func (cli *Client) BuildBaseURL(urlPath ...interface{}) string

BuildBaseURL builds a URL with the Client's homeserver/access_token set already. You must supply the prefix in the path.

func (*Client) BuildURL

func (cli *Client) BuildURL(urlPath ...interface{}) string

BuildURL builds a URL with the Client's homserver/prefix/access_token set already.

func (*Client) BuildURLWithQuery

func (cli *Client) BuildURLWithQuery(urlPath URLPath, urlQuery map[string]string) string

BuildURLWithQuery builds a URL with query parameters in addition to the Client's homeserver/prefix/access_token set already.

func (*Client) ClaimKeys

func (cli *Client) ClaimKeys(req *ReqClaimKeys) (resp *RespClaimKeys, err error)

func (*Client) ClearCredentials

func (cli *Client) ClearCredentials()

ClearCredentials removes the user ID and access token on this client instance.

func (*Client) CreateAlias

func (cli *Client) CreateAlias(alias id.RoomAlias, roomID id.RoomID) (resp *RespAliasCreate, err error)

func (*Client) CreateFilter

func (cli *Client) CreateFilter(filter *Filter) (resp *RespCreateFilter, err error)

CreateFilter makes an HTTP request according to

func (*Client) CreateRoom

func (cli *Client) CreateRoom(req *ReqCreateRoom) (resp *RespCreateRoom, err error)

CreateRoom creates a new Matrix room. See

resp, err := cli.CreateRoom(&mautrix.ReqCreateRoom{
	Preset: "public_chat",
fmt.Println("Room:", resp.RoomID)

func (*Client) DeleteAlias

func (cli *Client) DeleteAlias(alias id.RoomAlias) (resp *RespAliasDelete, err error)

func (*Client) DeletePushRule added in v0.4.11

func (cli *Client) DeletePushRule(scope string, kind pushrules.PushRuleType, ruleID string) error

func (*Client) Download

func (cli *Client) Download(mxcURL id.ContentURI) (io.ReadCloser, error)

func (*Client) DownloadBytes

func (cli *Client) DownloadBytes(mxcURL id.ContentURI) ([]byte, error)

func (*Client) ForgetRoom

func (cli *Client) ForgetRoom(roomID id.RoomID) (resp *RespForgetRoom, err error)

ForgetRoom forgets a room entirely. See

func (*Client) GetAvatarURL

func (cli *Client) GetAvatarURL() (url string, err error)

GetAvatarURL gets the user's avatar URL. See

func (*Client) GetDisplayName

func (cli *Client) GetDisplayName(mxid string) (resp *RespUserDisplayName, err error)

GetDisplayName returns the display name of the user from the specified MXID. See

func (*Client) GetDownloadURL

func (cli *Client) GetDownloadURL(mxcURL id.ContentURI) string

func (*Client) GetEvent

func (cli *Client) GetEvent(roomID id.RoomID, eventID id.EventID) (resp *event.Event, err error)

func (*Client) GetKeyChanges

func (cli *Client) GetKeyChanges(from, to string) (resp *RespKeyChanges, err error)

func (*Client) GetLoginFlows

func (cli *Client) GetLoginFlows() (resp *RespLoginFlows, err error)

func (*Client) GetOwnDisplayName

func (cli *Client) GetOwnDisplayName() (resp *RespUserDisplayName, err error)

GetOwnDisplayName returns the user's display name. See

func (*Client) GetPushRule added in v0.4.11

func (cli *Client) GetPushRule(scope string, kind pushrules.PushRuleType, ruleID string) (resp *pushrules.PushRule, err error)

func (*Client) GetPushRules

func (cli *Client) GetPushRules() (*pushrules.PushRuleset, error)

GetPushRules returns the push notification rules for the global scope.

func (*Client) GetScopedPushRules

func (cli *Client) GetScopedPushRules(scope string) (resp *pushrules.PushRuleset, err error)

GetScopedPushRules returns the push notification rules for the given scope.

func (*Client) InviteUser

func (cli *Client) InviteUser(roomID id.RoomID, req *ReqInviteUser) (resp *RespInviteUser, err error)

InviteUser invites a user to a room. See

func (*Client) InviteUserByThirdParty

func (cli *Client) InviteUserByThirdParty(roomID id.RoomID, req *ReqInvite3PID) (resp *RespInviteUser, err error)

InviteUserByThirdParty invites a third-party identifier to a room. See

func (*Client) JoinRoom

func (cli *Client) JoinRoom(roomIDorAlias, serverName string, content interface{}) (resp *RespJoinRoom, err error)

JoinRoom joins the client to a room ID or alias. See

If serverName is specified, this will be added as a query param to instruct the homeserver to join via that server. If content is specified, it will be JSON encoded and used as the request body.

func (*Client) JoinRoomByID added in v0.3.5

func (cli *Client) JoinRoomByID(roomID id.RoomID) (resp *RespJoinRoom, err error)

func (*Client) JoinedMembers

func (cli *Client) JoinedMembers(roomID id.RoomID) (resp *RespJoinedMembers, err error)

JoinedMembers returns a map of joined room members. See

In general, usage of this API is discouraged in favour of /sync, as calling this API can race with incoming membership changes. This API is primarily designed for application services which may want to efficiently look up joined members in a room.

func (*Client) JoinedRooms

func (cli *Client) JoinedRooms() (resp *RespJoinedRooms, err error)

JoinedRooms returns a list of rooms which the client is joined to. See

In general, usage of this API is discouraged in favour of /sync, as calling this API can race with incoming membership changes. This API is primarily designed for application services which may want to efficiently look up joined rooms.

func (*Client) KickUser

func (cli *Client) KickUser(roomID id.RoomID, req *ReqKickUser) (resp *RespKickUser, err error)

KickUser kicks a user from a room. See

func (*Client) LeaveRoom

func (cli *Client) LeaveRoom(roomID id.RoomID) (resp *RespLeaveRoom, err error)

LeaveRoom leaves the given room. See

func (*Client) LogRequest

func (cli *Client) LogRequest(req *http.Request, body string)

func (*Client) Login

func (cli *Client) Login(req *ReqLogin) (resp *RespLogin, err error)

Login a user to the homeserver according to

func (*Client) Logout

func (cli *Client) Logout() (resp *RespLogout, err error)

Logout the current user. See This does not clear the credentials from the client instance. See ClearCredentials() instead.

func (*Client) MakeRequest

func (cli *Client) MakeRequest(method string, httpURL string, reqBody interface{}, resBody interface{}) ([]byte, error)

MakeRequest makes a JSON HTTP request to the given URL. If "resBody" is not nil, the response body will be json.Unmarshalled into it.

Returns the HTTP body as bytes on 2xx with a nil error. Returns an error if the response is not 2xx along with the HTTP body bytes if it got that far. This error is an HTTPError which includes the returned HTTP status code and possibly a RespError as the WrappedError, if the HTTP body could be decoded as a RespError.

func (*Client) MarkRead

func (cli *Client) MarkRead(roomID id.RoomID, eventID id.EventID) (err error)

func (*Client) Members

func (cli *Client) Members(roomID id.RoomID, req ...ReqMembers) (resp *RespMembers, err error)

func (*Client) Messages

func (cli *Client) Messages(roomID id.RoomID, from, to string, dir rune, limit int) (resp *RespMessages, err error)

Messages returns a list of message and state events for a room. It uses pagination query parameters to paginate history in the room. See

func (*Client) PutPushRule added in v0.4.11

func (cli *Client) PutPushRule(scope string, kind pushrules.PushRuleType, ruleID string, req *ReqPutPushRule) error

func (*Client) QueryKeys

func (cli *Client) QueryKeys(req *ReqQueryKeys) (resp *RespQueryKeys, err error)

func (*Client) RedactEvent

func (cli *Client) RedactEvent(roomID id.RoomID, eventID id.EventID, extra ...ReqRedact) (resp *RespSendEvent, err error)

RedactEvent redacts the given event. See

func (*Client) Register

func (cli *Client) Register(req *ReqRegister) (*RespRegister, *RespUserInteractive, error)

Register makes an HTTP request according to

Registers with kind=user. For kind=guest, see RegisterGuest.

func (*Client) RegisterDummy

func (cli *Client) RegisterDummy(req *ReqRegister) (*RespRegister, error)

RegisterDummy performs m.login.dummy registration according to

Only a username and password need to be provided on the ReqRegister struct. Most local/developer homeservers will allow registration this way. If the homeserver does not, an error is returned.

This does not set credentials on the client instance. See SetCredentials() instead.

	res, err := cli.RegisterDummy(&mautrix.ReqRegister{
		Username: "alice",
		Password: "wonderland",
 if err != nil {
	token := res.AccessToken

func (*Client) RegisterGuest

func (cli *Client) RegisterGuest(req *ReqRegister) (*RespRegister, *RespUserInteractive, error)

RegisterGuest makes an HTTP request according to with kind=guest.

For kind=user, see Register.

func (*Client) RemoveTag

func (cli *Client) RemoveTag(roomID id.RoomID, tag string) (err error)

func (*Client) ResolveAlias

func (cli *Client) ResolveAlias(alias id.RoomAlias) (resp *RespAliasResolve, err error)

func (*Client) SendImage

func (cli *Client) SendImage(roomID id.RoomID, body string, url id.ContentURI) (*RespSendEvent, error)

SendImage sends an event into the given room with a msgtype of m.image See

func (*Client) SendMassagedStateEvent

func (cli *Client) SendMassagedStateEvent(roomID id.RoomID, eventType event.Type, stateKey string, contentJSON interface{}, ts int64) (resp *RespSendEvent, err error)

SendStateEvent sends a state event into a room. See contentJSON should be a pointer to something that can be encoded as JSON using json.Marshal.

func (*Client) SendMessageEvent

func (cli *Client) SendMessageEvent(roomID id.RoomID, eventType event.Type, contentJSON interface{}, extra ...ReqSendEvent) (resp *RespSendEvent, err error)

SendMessageEvent sends a message event into a room. See contentJSON should be a pointer to something that can be encoded as JSON using json.Marshal.

func (*Client) SendNotice

func (cli *Client) SendNotice(roomID id.RoomID, text string) (*RespSendEvent, error)

SendNotice sends an event into the given room with a msgtype of m.notice See

func (*Client) SendReaction

func (cli *Client) SendReaction(roomID id.RoomID, eventID id.EventID, reaction string) (*RespSendEvent, error)

func (*Client) SendStateEvent

func (cli *Client) SendStateEvent(roomID id.RoomID, eventType event.Type, stateKey string, contentJSON interface{}) (resp *RespSendEvent, err error)

SendStateEvent sends a state event into a room. See contentJSON should be a pointer to something that can be encoded as JSON using json.Marshal.

func (*Client) SendText

func (cli *Client) SendText(roomID id.RoomID, text string) (*RespSendEvent, error)

SendText sends an event into the given room with a msgtype of m.text See

func (*Client) SendToDevice

func (cli *Client) SendToDevice(eventType event.Type, req *ReqSendToDevice) (resp *RespSendToDevice, err error)

func (*Client) SendVideo

func (cli *Client) SendVideo(roomID id.RoomID, body string, url id.ContentURI) (*RespSendEvent, error)

SendVideo sends an event into the given room with a msgtype of See

func (*Client) SetAvatarURL

func (cli *Client) SetAvatarURL(url id.ContentURI) (err error)

SetAvatarURL sets the user's avatar URL. See

func (*Client) SetCredentials deprecated

func (cli *Client) SetCredentials(userID id.UserID, accessToken string)

SetCredentials sets the user ID and access token on this client instance.

Deprecated: use the StoreCredentials field in ReqLogin instead.

func (*Client) SetDisplayName

func (cli *Client) SetDisplayName(displayName string) (err error)

SetDisplayName sets the user's profile display name. See

func (*Client) SetPresence

func (cli *Client) SetPresence(status event.Presence) (err error)

func (*Client) SetTags

func (cli *Client) SetTags(roomID id.RoomID, tags event.Tags) (err error)

func (*Client) StateEvent

func (cli *Client) StateEvent(roomID id.RoomID, eventType event.Type, stateKey string, outContent interface{}) (err error)

StateEvent gets a single state event in a room. It will attempt to JSON unmarshal into the given "outContent" struct with the HTTP response body, or return an error. See

func (*Client) StopSync

func (cli *Client) StopSync()

StopSync stops the ongoing sync started by Sync.

func (*Client) Sync

func (cli *Client) Sync() error

Sync starts syncing with the provided Homeserver. If Sync() is called twice then the first sync will be stopped and the error will be nil.

This function will block until a fatal /sync error occurs, so it should almost always be started as a new goroutine. Fatal sync errors can be caused by:

  • The failure to create a filter.
  • Client.Syncer.OnFailedSync returning an error in response to a failed sync.
  • Client.Syncer.ProcessResponse returning an error.

If you wish to continue retrying in spite of these fatal errors, call Sync() again.

func (*Client) SyncRequest

func (cli *Client) SyncRequest(timeout int, since, filterID string, fullState bool, setPresence event.Presence) (resp *RespSync, err error)

SyncRequest makes an HTTP request according to

func (*Client) TurnServer

func (cli *Client) TurnServer() (resp *RespTurnServer, err error)

TurnServer returns turn server details and credentials for the client to use when initiating calls. See

func (*Client) TxnID

func (cli *Client) TxnID() string

TxnID returns the next transaction ID.

func (*Client) UnbanUser

func (cli *Client) UnbanUser(roomID id.RoomID, req *ReqUnbanUser) (resp *RespUnbanUser, err error)

UnbanUser unbans a user from a room. See

func (*Client) Upload deprecated

func (cli *Client) Upload(content io.Reader, contentType string, contentLength int64) (*RespMediaUpload, error)

UploadMedia uploads the given data to the content repository and returns an MXC URI.

Deprecated: UploadMedia should be used instead.

func (*Client) UploadBytes

func (cli *Client) UploadBytes(data []byte, contentType string) (*RespMediaUpload, error)

func (*Client) UploadBytesWithName added in v0.5.0

func (cli *Client) UploadBytesWithName(data []byte, contentType, fileName string) (*RespMediaUpload, error)

func (*Client) UploadKeys

func (cli *Client) UploadKeys(req *ReqUploadKeys) (resp *RespUploadKeys, err error)
func (cli *Client) UploadLink(link string) (*RespMediaUpload, error)

UploadLink uploads an HTTP URL and then returns an MXC URI.

func (*Client) UploadMedia added in v0.5.0

func (cli *Client) UploadMedia(data ReqUploadMedia) (*RespMediaUpload, error)

UploadMedia uploads the given data to the content repository and returns an MXC URI. See

func (*Client) UserTyping

func (cli *Client) UserTyping(roomID id.RoomID, typing bool, timeout int64) (resp *RespTyping, err error)

UserTyping sets the typing status of the user. See

func (*Client) Versions

func (cli *Client) Versions() (resp *RespVersions, err error)

Versions returns the list of supported Matrix versions on this homeserver. See

func (*Client) Whoami added in v0.3.6

func (cli *Client) Whoami() (resp *RespWhoami, err error)

type ClientWellKnown

type ClientWellKnown struct {
	Homeserver     HomeserverInfo     `json:"m.homeserver"`
	IdentityServer IdentityServerInfo `json:"m.identity_server"`

func DiscoverClientAPI

func DiscoverClientAPI(serverName string) (*ClientWellKnown, error)

DiscoverClientAPI resolves the client API URL from a Matrix server name. Use ParseUserID to extract the server name from a user ID.

type DefaultSyncer

type DefaultSyncer struct {

	// ParseEventContent determines whether or not event content should be parsed before passing to handlers.
	ParseEventContent bool
	// ParseErrorHandler is called when event.Content.ParseRaw returns an error.
	// If it returns false, the event will not be forwarded to listeners.
	ParseErrorHandler func(evt *event.Event, err error) bool
	// contains filtered or unexported fields

DefaultSyncer is the default syncing implementation. You can either write your own syncer, or selectively replace parts of this default syncer (e.g. the ProcessResponse method). The default syncer uses the observer pattern to notify callers about incoming events. See DefaultSyncer.OnEventType for more information.

func NewDefaultSyncer

func NewDefaultSyncer() *DefaultSyncer

NewDefaultSyncer returns an instantiated DefaultSyncer

func (*DefaultSyncer) GetFilterJSON

func (s *DefaultSyncer) GetFilterJSON(userID id.UserID) *Filter

GetFilterJSON returns a filter with a timeline limit of 50.

func (*DefaultSyncer) OnEvent added in v0.5.0

func (s *DefaultSyncer) OnEvent(callback EventHandler)

func (*DefaultSyncer) OnEventType

func (s *DefaultSyncer) OnEventType(eventType event.Type, callback EventHandler)

OnEventType allows callers to be notified when there are new events for the given event type. There are no duplicate checks.

func (*DefaultSyncer) OnFailedSync

func (s *DefaultSyncer) OnFailedSync(res *RespSync, err error) (time.Duration, error)

OnFailedSync always returns a 10 second wait period between failed /syncs, never a fatal error.

func (*DefaultSyncer) OnSync added in v0.5.0

func (s *DefaultSyncer) OnSync(callback SyncHandler)

func (*DefaultSyncer) ProcessResponse

func (s *DefaultSyncer) ProcessResponse(res *RespSync, since string) (err error)

ProcessResponse processes the /sync response in a way suitable for bots. "Suitable for bots" means a stream of unrepeating events. Returns a fatal error if a listener panics.

type DeviceIDList

type DeviceIDList []id.DeviceID

type DeviceKeys

type DeviceKeys struct {
	UserID     id.UserID              `json:"user_id"`
	DeviceID   id.DeviceID            `json:"device_id"`
	Algorithms []id.Algorithm         `json:"algorithms"`
	Keys       KeyMap                 `json:"keys"`
	Signatures Signatures             `json:"signatures"`
	Unsigned   map[string]interface{} `json:"unsigned,omitempty"`

type DeviceKeysRequest

type DeviceKeysRequest map[id.UserID]DeviceIDList

type EventFormat

type EventFormat string
const (
	EventFormatClient     EventFormat = "client"
	EventFormatFederation EventFormat = "federation"

type EventHandler added in v0.5.0

type EventHandler func(source EventSource, evt *event.Event)

EventHandler handles a single event from a sync response.

type EventSource added in v0.3.5

type EventSource int

EventSource represents the part of the sync response that an event came from.

const (
	EventSourcePresence EventSource = 1 << iota

func (EventSource) String added in v0.3.5

func (es EventSource) String() string

type ExtensibleSyncer added in v0.5.0

type ExtensibleSyncer interface {
	OnSync(callback SyncHandler)
	OnEvent(callback EventHandler)
	OnEventType(eventType event.Type, callback EventHandler)

type Filter

type Filter struct {
	AccountData FilterPart  `json:"account_data,omitempty"`
	EventFields []string    `json:"event_fields,omitempty"`
	EventFormat EventFormat `json:"event_format,omitempty"`
	Presence    FilterPart  `json:"presence,omitempty"`
	Room        RoomFilter  `json:"room,omitempty"`

Filter is used by clients to specify how the server should filter responses to e.g. sync requests Specified by:

func DefaultFilter

func DefaultFilter() Filter

DefaultFilter returns the default filter used by the Matrix server if no filter is provided in the request

func (*Filter) Validate

func (filter *Filter) Validate() error

Validate checks if the filter contains valid property values

type FilterPart

type FilterPart struct {
	NotRooms    []id.RoomID  `json:"not_rooms,omitempty"`
	Rooms       []id.RoomID  `json:"rooms,omitempty"`
	Limit       int          `json:"limit,omitempty"`
	NotSenders  []id.UserID  `json:"not_senders,omitempty"`
	NotTypes    []event.Type `json:"not_types,omitempty"`
	Senders     []id.UserID  `json:"senders,omitempty"`
	Types       []event.Type `json:"types,omitempty"`
	ContainsURL *bool        `json:"contains_url,omitempty"`

	LazyLoadMembers         bool `json:"lazy_load_members,omitempty"`
	IncludeRedundantMembers bool `json:"include_redundant_members,omitempty"`

FilterPart is used to define filtering rules for specific categories of events

func DefaultFilterPart

func DefaultFilterPart() FilterPart

DefaultFilterPart returns the default filter part used by the Matrix server if no filter is provided in the request

type HTTPError

type HTTPError struct {
	WrappedError error
	RespError    *RespError
	Message      string
	Code         int

HTTPError An HTTP Error response, which may wrap an underlying native Go Error.

func (HTTPError) Error

func (e HTTPError) Error() string

type HomeserverInfo

type HomeserverInfo struct {
	BaseURL string `json:"base_url"`

type IdentifierType added in v0.7.1

type IdentifierType string

type IdentityServerInfo

type IdentityServerInfo struct {
	BaseURL string `json:"base_url"`

type InMemoryStore

type InMemoryStore struct {
	Filters   map[id.UserID]string
	NextBatch map[id.UserID]string
	Rooms     map[id.RoomID]*Room

InMemoryStore implements the Storer interface.

Everything is persisted in-memory as maps. It is not safe to load/save filter IDs or next batch tokens on any goroutine other than the syncing goroutine: the one which called Client.Sync().

func NewInMemoryStore

func NewInMemoryStore() *InMemoryStore

NewInMemoryStore constructs a new InMemoryStore.

func (*InMemoryStore) LoadFilterID

func (s *InMemoryStore) LoadFilterID(userID id.UserID) string

LoadFilterID from memory.

func (*InMemoryStore) LoadNextBatch

func (s *InMemoryStore) LoadNextBatch(userID id.UserID) string

LoadNextBatch from memory.

func (*InMemoryStore) LoadRoom

func (s *InMemoryStore) LoadRoom(roomID id.RoomID) *Room

LoadRoom from memory.

func (*InMemoryStore) SaveFilterID

func (s *InMemoryStore) SaveFilterID(userID id.UserID, filterID string)

SaveFilterID to memory.

func (*InMemoryStore) SaveNextBatch

func (s *InMemoryStore) SaveNextBatch(userID id.UserID, nextBatchToken string)

SaveNextBatch to memory.

func (*InMemoryStore) SaveRoom

func (s *InMemoryStore) SaveRoom(room *Room)

SaveRoom to memory.

func (*InMemoryStore) UpdateState added in v0.5.0

func (s *InMemoryStore) UpdateState(_ EventSource, evt *event.Event)

UpdateState stores a state event. This can be passed to DefaultSyncer.OnEvent to keep all room state cached.

type KeyMap

type KeyMap map[id.DeviceKeyID]string

func (KeyMap) GetCurve25519

func (km KeyMap) GetCurve25519(deviceID id.DeviceID) id.Curve25519

func (KeyMap) GetEd25519

func (km KeyMap) GetEd25519(deviceID id.DeviceID) id.Ed25519

type LazyLoadSummary

type LazyLoadSummary struct {
	Heroes             []id.UserID `json:"m.heroes,omitempty"`
	JoinedMemberCount  *int        `json:"m.joined_member_count,omitempty"`
	InvitedMemberCount *int        `json:"m.invited_member_count,omitempty"`

type Logger

type Logger interface {
	Debugfln(message string, args ...interface{})

type OldEventIgnorer added in v0.5.0

type OldEventIgnorer struct {
	UserID id.UserID

OldEventIgnorer is an utility struct for bots to ignore events from before the bot joined the room. Create a struct and call Register with your DefaultSyncer to register the sync handler.

func (*OldEventIgnorer) DontProcessOldEvents added in v0.5.0

func (oei *OldEventIgnorer) DontProcessOldEvents(resp *RespSync, since string) bool

DontProcessOldEvents returns true if a sync response should be processed. May modify the response to remove stuff that shouldn't be processed.

func (*OldEventIgnorer) Register added in v0.5.0

func (oei *OldEventIgnorer) Register(syncer ExtensibleSyncer)

type OneTimeKey

type OneTimeKey struct {
	Key        id.Curve25519          `json:"key"`
	IsSigned   bool                   `json:"-"`
	Signatures Signatures             `json:"signatures,omitempty"`
	Unsigned   map[string]interface{} `json:"unsigned,omitempty"`

func (*OneTimeKey) MarshalJSON

func (otk *OneTimeKey) MarshalJSON() ([]byte, error)

func (*OneTimeKey) UnmarshalJSON

func (otk *OneTimeKey) UnmarshalJSON(data []byte) (err error)

type OneTimeKeysCount

type OneTimeKeysCount struct {
	Curve25519       int `json:"curve25519"`
	SignedCurve25519 int `json:"signed_curve25519"`

type OneTimeKeysRequest

type OneTimeKeysRequest map[id.UserID]map[id.DeviceID]id.KeyAlgorithm

type ReqAliasCreate

type ReqAliasCreate struct {
	RoomID id.RoomID `json:"room_id"`

type ReqBanUser

type ReqBanUser struct {
	Reason string    `json:"reason,omitempty"`
	UserID id.UserID `json:"user_id"`

ReqBanUser is the JSON request for

type ReqClaimKeys

type ReqClaimKeys struct {
	OneTimeKeys OneTimeKeysRequest `json:"one_time_keys"`

	Timeout int64 `json:"timeout,omitempty"`

type ReqCreateRoom

type ReqCreateRoom struct {
	Visibility      string                 `json:"visibility,omitempty"`
	RoomAliasName   string                 `json:"room_alias_name,omitempty"`
	Name            string                 `json:"name,omitempty"`
	Topic           string                 `json:"topic,omitempty"`
	Invite          []id.UserID            `json:"invite,omitempty"`
	Invite3PID      []ReqInvite3PID        `json:"invite_3pid,omitempty"`
	CreationContent map[string]interface{} `json:"creation_content,omitempty"`
	InitialState    []*event.Event         `json:"initial_state,omitempty"`
	Preset          string                 `json:"preset,omitempty"`
	IsDirect        bool                   `json:"is_direct,omitempty"`

ReqCreateRoom is the JSON request for

type ReqInvite3PID

type ReqInvite3PID struct {
	IDServer string `json:"id_server"`
	Medium   string `json:"medium"`
	Address  string `json:"address"`

ReqInvite3PID is the JSON request for It is also a JSON object used in

type ReqInviteUser

type ReqInviteUser struct {
	UserID id.UserID `json:"user_id"`

ReqInviteUser is the JSON request for

type ReqKickUser

type ReqKickUser struct {
	Reason string    `json:"reason,omitempty"`
	UserID id.UserID `json:"user_id"`

ReqKickUser is the JSON request for

type ReqLogin

type ReqLogin struct {
	Type                     AuthType       `json:"type"`
	Identifier               UserIdentifier `json:"identifier"`
	Password                 string         `json:"password,omitempty"`
	Token                    string         `json:"token,omitempty"`
	DeviceID                 id.DeviceID    `json:"device_id,omitempty"`
	InitialDeviceDisplayName string         `json:"initial_device_display_name,omitempty"`

	// Whether or not the returned credentials should be stored in the Client
	StoreCredentials bool `json:"-"`

ReqLogin is the JSON request for

type ReqMembers

type ReqMembers struct {
	At            string           `json:"at"`
	Membership    event.Membership `json:"membership,omitempty"`
	NotMembership event.Membership `json:"not_membership,omitempty"`

type ReqPresence

type ReqPresence struct {
	Presence event.Presence `json:"presence"`

type ReqPutPushRule added in v0.4.11

type ReqPutPushRule struct {
	Before string `json:"-"`
	After  string `json:"-"`

	Actions    []pushrules.PushActionType `json:"actions"`
	Conditions []pushrules.PushCondition  `json:"conditions"`
	Pattern    string                     `json:"pattern"`

type ReqQueryKeys

type ReqQueryKeys struct {
	DeviceKeys DeviceKeysRequest `json:"device_keys"`

	Timeout int64  `json:"timeout,omitempty"`
	Token   string `json:"token,omitempty"`

type ReqRedact

type ReqRedact struct {
	Reason string `json:"reason,omitempty"`
	TxnID  string `json:"-"`

ReqRedact is the JSON request for

type ReqRegister

type ReqRegister struct {
	Username                 string      `json:"username,omitempty"`
	BindEmail                bool        `json:"bind_email,omitempty"`
	Password                 string      `json:"password,omitempty"`
	DeviceID                 id.DeviceID `json:"device_id,omitempty"`
	InitialDeviceDisplayName string      `json:"initial_device_display_name"`
	Auth                     interface{} `json:"auth,omitempty"`

ReqRegister is the JSON request for

type ReqSendEvent

type ReqSendEvent struct {
	Timestamp     int64
	TransactionID string

	ParentID string
	RelType  event.RelationType

type ReqSendToDevice

type ReqSendToDevice struct {
	Messages map[id.UserID]map[id.DeviceID]*event.Content `json:"messages"`

type ReqTyping

type ReqTyping struct {
	Typing  bool  `json:"typing"`
	Timeout int64 `json:"timeout,omitempty"`

ReqTyping is the JSON request for

type ReqUnbanUser

type ReqUnbanUser struct {
	UserID id.UserID `json:"user_id"`

ReqUnbanUser is the JSON request for

type ReqUploadKeys

type ReqUploadKeys struct {
	DeviceKeys  *DeviceKeys             `json:"device_keys,omitempty"`
	OneTimeKeys map[id.KeyID]OneTimeKey `json:"one_time_keys"`

type ReqUploadMedia added in v0.5.0

type ReqUploadMedia struct {
	Content       io.Reader
	ContentLength int64
	ContentType   string
	FileName      string

type RespAliasCreate

type RespAliasCreate struct{}

type RespAliasDelete

type RespAliasDelete struct{}

type RespAliasResolve

type RespAliasResolve struct {
	RoomID  id.RoomID `json:"room_id"`
	Servers []string  `json:"servers"`

type RespBanUser

type RespBanUser struct{}

RespBanUser is the JSON response for

type RespClaimKeys

type RespClaimKeys struct {
	Failures    map[string]interface{}                                `json:"failures"`
	OneTimeKeys map[id.UserID]map[id.DeviceID]map[id.KeyID]OneTimeKey `json:"one_time_keys"`

type RespCreateFilter

type RespCreateFilter struct {
	FilterID string `json:"filter_id"`

RespCreateFilter is the JSON response for

type RespCreateRoom

type RespCreateRoom struct {
	RoomID id.RoomID `json:"room_id"`

RespCreateRoom is the JSON response for

type RespError

type RespError struct {
	ErrCode string `json:"errcode"`
	Err     string `json:"error"`

RespError is the standard JSON error response from Homeservers. It also implements the Golang "error" interface. See

func (RespError) Error

func (e RespError) Error() string

Error returns the errcode and error message.

type RespForgetRoom

type RespForgetRoom struct{}

RespForgetRoom is the JSON response for

type RespInviteUser

type RespInviteUser struct{}

RespInviteUser is the JSON response for

type RespJoinRoom

type RespJoinRoom struct {
	RoomID id.RoomID `json:"room_id"`

RespJoinRoom is the JSON response for

type RespJoinedMembers

type RespJoinedMembers struct {
	Joined map[id.UserID]struct {
		DisplayName *string `json:"display_name"`
		AvatarURL   *string `json:"avatar_url"`
	} `json:"joined"`

RespJoinedMembers is the JSON response for

type RespJoinedRooms

type RespJoinedRooms struct {
	JoinedRooms []id.RoomID `json:"joined_rooms"`

RespJoinedRooms is the JSON response for

type RespKeyChanges

type RespKeyChanges struct {
	Changed []id.UserID `json:"changed"`
	Left    []id.UserID `json:"left"`

type RespKickUser

type RespKickUser struct{}

RespKickUser is the JSON response for

type RespLeaveRoom

type RespLeaveRoom struct{}

RespLeaveRoom is the JSON response for

type RespLogin

type RespLogin struct {
	AccessToken string      `json:"access_token"`
	DeviceID    id.DeviceID `json:"device_id"`
	UserID      id.UserID   `json:"user_id"`

RespLogin is the JSON response for

type RespLoginFlows

type RespLoginFlows struct {
	Flows []struct {
		Type string `json:"type"`
	} `json:"flows"`

type RespLogout

type RespLogout struct{}

RespLogout is the JSON response for

type RespMediaUpload

type RespMediaUpload struct {
	ContentURI id.ContentURI `json:"content_uri"`

RespMediaUpload is the JSON response for

type RespMembers

type RespMembers struct {
	Chunk []*event.Event `json:"chunk"`

type RespMessages

type RespMessages struct {
	Start string         `json:"start"`
	Chunk []*event.Event `json:"chunk"`
	State []*event.Event `json:"state"`
	End   string         `json:"end"`

RespMessages is the JSON response for

type RespQueryKeys

type RespQueryKeys struct {
	Failures   map[string]interface{}                   `json:"failures"`
	DeviceKeys map[id.UserID]map[id.DeviceID]DeviceKeys `json:"device_keys"`

type RespRegister

type RespRegister struct {
	AccessToken  string      `json:"access_token"`
	DeviceID     id.DeviceID `json:"device_id"`
	HomeServer   string      `json:"home_server"`
	RefreshToken string      `json:"refresh_token"`
	UserID       id.UserID   `json:"user_id"`

RespRegister is the JSON response for

type RespSendEvent

type RespSendEvent struct {
	EventID id.EventID `json:"event_id"`

RespSendEvent is the JSON response for

type RespSendToDevice

type RespSendToDevice struct{}

type RespSync

type RespSync struct {
	NextBatch string `json:"next_batch"`

	AccountData struct {
		Events []*event.Event `json:"events"`
	} `json:"account_data"`
	Presence struct {
		Events []*event.Event `json:"events"`
	} `json:"presence"`
	ToDevice struct {
		Events []*event.Event `json:"events"`
	} `json:"to_device"`

	DeviceLists struct {
		Changed []id.UserID `json:"changed"`
		Left    []id.UserID `json:"left"`
	} `json:"device_lists"`
	DeviceOneTimeKeysCount OneTimeKeysCount `json:"device_one_time_keys_count"`

	Rooms struct {
		Leave  map[id.RoomID]SyncLeftRoom    `json:"leave"`
		Join   map[id.RoomID]SyncJoinedRoom  `json:"join"`
		Invite map[id.RoomID]SyncInvitedRoom `json:"invite"`
	} `json:"rooms"`

RespSync is the JSON response for

type RespTurnServer

type RespTurnServer struct {
	Username string   `json:"username"`
	Password string   `json:"password"`
	TTL      int      `json:"ttl"`
	URIs     []string `json:"uris"`

type RespUnbanUser

type RespUnbanUser struct{}

RespUnbanUser is the JSON response for

type RespUploadKeys

type RespUploadKeys struct {
	OneTimeKeyCounts OneTimeKeysCount `json:"one_time_key_counts"`

type RespUserDisplayName

type RespUserDisplayName struct {
	DisplayName string `json:"displayname"`

RespUserDisplayName is the JSON response for

type RespUserInteractive

type RespUserInteractive struct {
	Flows []struct {
		Stages []AuthType `json:"stages"`
	} `json:"flows"`
	Params    map[AuthType]interface{} `json:"params"`
	Session   string                   `json:"string"`
	Completed []string                 `json:"completed"`

	ErrCode string `json:"errcode"`
	Error   string `json:"error"`

RespUserInteractive is the JSON response for

func (RespUserInteractive) HasSingleStageFlow

func (r RespUserInteractive) HasSingleStageFlow(stageName AuthType) bool

HasSingleStageFlow returns true if there exists at least 1 Flow with a single stage of stageName.

type RespVersions

type RespVersions struct {
	Versions []string `json:"versions"`

RespVersions is the JSON response for

type RespWhoami added in v0.3.6

type RespWhoami struct {
	UserID id.UserID `json:"user_id"`

type Room

type Room struct {
	ID    id.RoomID
	State map[event.Type]map[string]*event.Event

Room represents a single Matrix room.

func NewRoom

func NewRoom(roomID id.RoomID) *Room

NewRoom creates a new Room with the given ID

func (Room) GetMembershipState

func (room Room) GetMembershipState(userID id.UserID) event.Membership

GetMembershipState returns the membership state of the given user ID in this room. If there is no entry for this member, 'leave' is returned for consistency with left users.

func (Room) GetStateEvent

func (room Room) GetStateEvent(eventType event.Type, stateKey string) *event.Event

GetStateEvent returns the state event for the given type/state_key combo, or nil.

func (Room) UpdateState

func (room Room) UpdateState(evt *event.Event)

UpdateState updates the room's current state with the given Event. This will clobber events based on the type/state_key combination.

type RoomFilter

type RoomFilter struct {
	AccountData  FilterPart  `json:"account_data,omitempty"`
	Ephemeral    FilterPart  `json:"ephemeral,omitempty"`
	IncludeLeave bool        `json:"include_leave,omitempty"`
	NotRooms     []id.RoomID `json:"not_rooms,omitempty"`
	Rooms        []id.RoomID `json:"rooms,omitempty"`
	State        FilterPart  `json:"state,omitempty"`
	Timeline     FilterPart  `json:"timeline,omitempty"`

RoomFilter is used to define filtering rules for room events

type Signatures

type Signatures map[id.UserID]map[id.DeviceKeyID]string

type Storer

type Storer interface {
	SaveFilterID(userID id.UserID, filterID string)
	LoadFilterID(userID id.UserID) string
	SaveNextBatch(userID id.UserID, nextBatchToken string)
	LoadNextBatch(userID id.UserID) string
	SaveRoom(room *Room)
	LoadRoom(roomID id.RoomID) *Room

Storer is an interface which must be satisfied to store client data.

You can either write a struct which persists this data to disk, or you can use the provided "InMemoryStore" which just keeps data around in-memory which is lost on restarts.

type Stringifiable

type Stringifiable interface {
	String() string

type SyncHandler added in v0.5.0

type SyncHandler func(resp *RespSync, since string) bool

SyncHandler handles a whole sync response. If the return value is false, handling will be stopped completely.

type SyncInvitedRoom

type SyncInvitedRoom struct {
	Summary LazyLoadSummary `json:"summary"`
	State   struct {
		Events []*event.Event `json:"events"`
	} `json:"invite_state"`

type SyncJoinedRoom

type SyncJoinedRoom struct {
	Summary LazyLoadSummary `json:"summary"`
	State   struct {
		Events []*event.Event `json:"events"`
	} `json:"state"`
	Timeline struct {
		Events    []*event.Event `json:"events"`
		Limited   bool           `json:"limited"`
		PrevBatch string         `json:"prev_batch"`
	} `json:"timeline"`
	Ephemeral struct {
		Events []*event.Event `json:"events"`
	} `json:"ephemeral"`
	AccountData struct {
		Events []*event.Event `json:"events"`
	} `json:"account_data"`

type SyncLeftRoom

type SyncLeftRoom struct {
	Summary LazyLoadSummary `json:"summary"`
	State   struct {
		Events []*event.Event `json:"events"`
	} `json:"state"`
	Timeline struct {
		Events    []*event.Event `json:"events"`
		Limited   bool           `json:"limited"`
		PrevBatch string         `json:"prev_batch"`
	} `json:"timeline"`

type Syncer

type Syncer interface {
	// Process the /sync response. The since parameter is the since= value that was used to produce the response.
	// This is useful for detecting the very first sync (since=""). If an error is return, Syncing will be stopped
	// permanently.
	ProcessResponse(resp *RespSync, since string) error
	// OnFailedSync returns either the time to wait before retrying or an error to stop syncing permanently.
	OnFailedSync(res *RespSync, err error) (time.Duration, error)
	// GetFilterJSON for the given user ID. NOT the filter ID.
	GetFilterJSON(userID id.UserID) *Filter

Syncer is an interface that must be satisfied in order to do /sync requests on a client.

type URLPath

type URLPath = []interface{}

type UserIdentifier

type UserIdentifier struct {
	Type IdentifierType `json:"type"`

	User string `json:"user,omitempty"`

	Medium  string `json:"medium,omitempty"`
	Address string `json:"address,omitempty"`

	Country string `json:"country,omitempty"`
	Phone   string `json:"phone,omitempty"`


Path Synopsis
Package format contains utilities for working with Matrix HTML, specifically methods to parse Markdown into HTML and to parse Matrix HTML into text or markdown.
Package format contains utilities for working with Matrix HTML, specifically methods to parse Markdown into HTML and to parse Matrix HTML into text or markdown.
Package pushrules contains utilities to parse push notification rules.
Package pushrules contains utilities to parse push notification rules.
Package glob provides objects for matching strings with globs
Package glob provides objects for matching strings with globs

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL