matrixolm

type Ciphertext struct {
	Type olm.MsgType `json:"type"`
	Body string      `json:"body"`
}

type Client struct {
	mat.Client
	Crypto *Container
	// contains filtered or unexported fields
}

type Container struct {
	Me *MyUserDevice
	// contains filtered or unexported fields
}

type ContentRoomMember struct {
	DisplayName string `json:"displayname"`
	Membership  string `json:"membership"`
}

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

type Databaser interface {
	Close()
	AddUser(userID mat.UserID) error
	AddUserDevice(userID mat.UserID, deviceID mat.DeviceID) error
	AddMyUserMyDevice(userID mat.UserID, deviceID mat.DeviceID) error
	StorePubKeys(userID mat.UserID, deviceID mat.DeviceID,
		ed25519 olm.Ed25519, curve25519 olm.Curve25519) error
	StoreOlmSession(userID mat.UserID, deviceID mat.DeviceID,
		olmSession *olm.Session) error
	StoreMegolmInSession(userID mat.UserID, deviceID mat.DeviceID,
		megolmInSession *olm.InboundGroupSession) error
	SetSharedMegolmOutKey(userID mat.UserID, deviceID mat.DeviceID,
		sessionID olm.SessionID) error
	StoreMegolmOutSession(userID mat.UserID, deviceID mat.DeviceID,
		megolmOutSession *olm.OutboundGroupSession) error
	LoadAllUserDevices() (map[mat.UserID]*UserDevices, error)
	LoadMyUserDevice(userID mat.UserID) (*MyUserDevice, error)
	ExistsOlmAccount(userID mat.UserID, deviceID mat.DeviceID) bool
	StoreOlmAccount(userID mat.UserID, deviceID mat.DeviceID, olmAccount *olm.Account) error
	StoreOlmSessionID(roomID mat.RoomID, userID mat.UserID, key olm.Curve25519,
		sessionID olm.SessionID) error
	StoreMegolmInSessionID(roomID mat.RoomID, userID mat.UserID, key olm.Curve25519,
		sessionID olm.SessionID) error
	LoadMapSessionsID() (*RoomsSessionsID, error)
	LoadRooms() (map[mat.RoomID]*Room, error)
	StoreRoomEncryptionAlg(roomID mat.RoomID, encryptionAlg olm.Algorithm) error
}

type DecryptedEvent struct {
	Error error
	Event *Event
}

type Device struct {

	//OneTimeKey       string                              // IdentityKey
	OlmSessions      map[olm.SessionID]*olm.Session
	MegolmInSessions map[olm.SessionID]*olm.InboundGroupSession
	// contains filtered or unexported fields
}

type Event struct {
	mat.Event
	Decrypted *DecryptedEvent `json:"-"`
}

type Logger interface {
	Debugf(format string, args ...interface{})
	Errorf(format string, args ...interface{})
}

type MegolmMsg struct {
	Algorithm  olm.Algorithm  `json:"algorithm"`
	Ciphertext string         `json:"ciphertext"`
	DeviceID   mat.DeviceID   `json:"device_id"`
	SenderKey  olm.Curve25519 `json:"sender_key"`
	SessionID  olm.SessionID  `json:"session_id"`
}

type Membership int

type MyDevice struct {
	ID mat.DeviceID

	OlmAccount *olm.Account
	//OlmSessions       map[string]*olm.Session              // key:room_id
	MegolmOutSessions map[mat.RoomID]*olm.OutboundGroupSession
	// contains filtered or unexported fields
}

type MyUserDevice struct {
	ID     mat.UserID
	Device *MyDevice
}

type OlmMsg struct {
	Algorithm  olm.Algorithm  `json:"algorithm"`
	SenderKey  olm.Curve25519 `json:"sender_key"`
	Ciphertext map[olm.Curve25519]struct {
		Type olm.MsgType `json:"type"`
		Body string      `json:"body"`
	} `json:"ciphertext"`
}

type RespSync struct {
	NextBatch   string `json:"next_batch"`
	AccountData struct {
		Events []Event `json:"events"`
	} `json:"account_data"`
	Presence struct {
		Events []Event `json:"events"`
	} `json:"presence"`
	Rooms struct {
		Leave map[string]struct {
			State struct {
				Events []Event `json:"events"`
			} `json:"state"`
			Timeline struct {
				Events    []Event `json:"events"`
				Limited   bool    `json:"limited"`
				PrevBatch string  `json:"prev_batch"`
			} `json:"timeline"`
		} `json:"leave"`
		Join map[string]struct {
			State struct {
				Events []Event `json:"events"`
			} `json:"state"`
			Timeline struct {
				Events    []Event `json:"events"`
				Limited   bool    `json:"limited"`
				PrevBatch string  `json:"prev_batch"`
			} `json:"timeline"`
		} `json:"join"`
		Invite map[string]struct {
			State struct {
				Events []Event
			} `json:"invite_state"`
		} `json:"invite"`
	} `json:"rooms"`
	ToDevice struct {
		Events []SendToDeviceEvent `json:"events"`
	} `json:"to_device"`
}

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

type RoomKey struct {
	// OlmSenderKey is filled when this event is obtained through the
	// decryption of an m.room.encrypted event.
	OlmSenderKey olm.Curve25519
	Algorithm    olm.Algorithm `json:"algorithm"`
	RoomID       mat.RoomID    `json:"room_id"`
	SessionID    olm.SessionID `json:"session_id"`
	SessionKey   string        `json:"session_key"`
}

type RoomsSessionsID struct {
	Sessions map[SessionTriplet]*SessionsID
}

type SendEncEventError struct {
	UserID   mat.UserID
	DeviceID mat.DeviceID
	//Content  interface{}
	Err error
}

type SendEncEventErrors []SendEncEventError

type SendToDeviceEvent struct {
	mat.SendToDeviceEvent
	Decrypted *DecryptedEvent `json:"-"`
}

type SessionTriplet struct {
	RoomID mat.RoomID
	UserID mat.UserID
	Key    olm.Curve25519
}

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

type SignedKey struct {
	Key        olm.Curve25519               `json:"key"`
	Signatures map[string]map[string]string `json:"signatures"`
}

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

type UserDevices struct {
	Devices     map[olm.Curve25519]*Device
	DevicesByID map[mat.DeviceID]*Device
	// contains filtered or unexported fields
}