matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/core/keys.js

@@ -0,0 +1,450 @@
+import { isObject } from "./json.js";
+import { UNSTABLE } from "./m.js";
+import { errors } from "./errors.js";
+//#region src/core/keys.ts
+/** End-to-end encryption key storage (device keys, one-time keys, cross-signing). */
+var KeyService = class {
+	hs;
+	constructor(hs) {
+		this.hs = hs;
+	}
+	/** A local user's devices or device keys changed: update local clients and remote servers. */
+	async deviceChanged(userId, deletedDeviceId) {
+		await this.markDeviceListChanged(userId);
+		await this.hs.federation.onDeviceListChange(userId, deletedDeviceId).catch((err) => this.hs.logger.warn("Device list EDU failed", err));
+	}
+	async markDeviceListChanged(userId, notify = true) {
+		await this.hs.streams.write((stream) => this.hs.db.upsert("device_list_changes", {
+			user_id: userId,
+			stream
+		}));
+		if (notify) this.hs.notifier.notify(await this.hs.rooms.usersSharingRooms(userId));
+	}
+	/**
+	* A partial-state room got its full state (MSC3902): device list updates received meanwhile for
+	* users we could not place count as changes now, if those users turned out to be members.
+	*/
+	async onPartialStateComplete(roomId, pendingUsers) {
+		const members = new Set(await this.hs.rooms.joinedMembers(roomId));
+		for (const userId of pendingUsers) if (members.has(userId)) await this.markDeviceListChanged(userId, false);
+		this.hs.notifier.notify([...members].filter((u) => this.hs.isLocalUser(u)));
+	}
+	async upload(userId, deviceId, body) {
+		if (body.device_keys !== void 0) {
+			const dk = body.device_keys;
+			if (!isObject(dk) || dk.user_id !== userId || dk.device_id !== deviceId) throw errors.invalidParam("device_keys do not match this device");
+			if (!Array.isArray(dk.algorithms) || !isObject(dk.keys) || !isObject(dk.signatures)) throw errors.badJson("device_keys must contain algorithms, keys and signatures");
+			const existing = await this.hs.db.findOne("device_keys", [{
+				field: "user_id",
+				value: userId
+			}, {
+				field: "device_id",
+				value: deviceId
+			}]);
+			if (!existing || JSON.stringify(existing.keys) !== JSON.stringify(dk)) {
+				await this.hs.streams.write((stream) => this.hs.db.upsert("device_keys", {
+					user_id: userId,
+					device_id: deviceId,
+					keys: dk,
+					stream
+				}));
+				await this.deviceChanged(userId);
+			}
+		}
+		const device = [{
+			field: "user_id",
+			value: userId
+		}, {
+			field: "device_id",
+			value: deviceId
+		}];
+		if (isObject(body.one_time_keys)) for (const [fullId, key] of Object.entries(body.one_time_keys)) {
+			const [algorithm] = fullId.split(":");
+			const existing = await this.hs.db.findOne("one_time_keys", [...device, {
+				field: "key_id",
+				value: fullId
+			}]);
+			if (existing) {
+				if (JSON.stringify(existing.key) !== JSON.stringify(key)) throw errors.invalidParam(`One time key ${fullId} already exists`);
+				continue;
+			}
+			await this.hs.streams.write((seq) => this.hs.db.create("one_time_keys", {
+				user_id: userId,
+				device_id: deviceId,
+				key_id: fullId,
+				algorithm,
+				key,
+				fallback: false,
+				used: false,
+				seq
+			}));
+		}
+		const fallbackKeys = body.fallback_keys ?? body[UNSTABLE.ORG.MATRIX.MSC2732.FALLBACK_KEYS];
+		if (isObject(fallbackKeys)) for (const [fullId, key] of Object.entries(fallbackKeys)) {
+			const [algorithm] = fullId.split(":");
+			const existing = await this.hs.db.findOne("fallback_keys", [...device, {
+				field: "algorithm",
+				value: algorithm
+			}]);
+			if (existing && existing.key_id === fullId && JSON.stringify(existing.key) === JSON.stringify(key)) continue;
+			await this.hs.db.upsert("fallback_keys", {
+				user_id: userId,
+				device_id: deviceId,
+				algorithm,
+				key_id: fullId,
+				key,
+				used: false
+			});
+		}
+		return this.oneTimeKeyCounts(userId, deviceId);
+	}
+	async oneTimeKeyCounts(userId, deviceId) {
+		const rows = await this.hs.db.findMany("one_time_keys", { where: [
+			{
+				field: "user_id",
+				value: userId
+			},
+			{
+				field: "device_id",
+				value: deviceId
+			},
+			{
+				field: "fallback",
+				value: false
+			}
+		] });
+		const counts = { signed_curve25519: 0 };
+		for (const r of rows) counts[r.algorithm] = (counts[r.algorithm] ?? 0) + 1;
+		return counts;
+	}
+	async unusedFallbackKeyTypes(userId, deviceId) {
+		const rows = await this.hs.db.findMany("fallback_keys", { where: [
+			{
+				field: "user_id",
+				value: userId
+			},
+			{
+				field: "device_id",
+				value: deviceId
+			},
+			{
+				field: "used",
+				value: false
+			}
+		] });
+		return [...new Set(rows.map((r) => r.algorithm))];
+	}
+	async query(requester, deviceKeys, timeoutMs = 1e4) {
+		const result = {
+			device_keys: {},
+			failures: {},
+			master_keys: {},
+			self_signing_keys: {},
+			user_signing_keys: {}
+		};
+		const remote = {};
+		for (const [userId, devices] of Object.entries(deviceKeys ?? {})) {
+			if (!this.hs.isLocalUser(userId)) {
+				remote[userId] = devices;
+				continue;
+			}
+			const rows = await this.hs.db.findMany("device_keys", { where: [{
+				field: "user_id",
+				value: userId
+			}] });
+			const deviceRows = await this.hs.db.findMany("devices", { where: [{
+				field: "user_id",
+				value: userId
+			}] });
+			const names = new Map(deviceRows.map((d) => [d.device_id, d.display_name]));
+			const wanted = Array.isArray(devices) && devices.length ? new Set(devices) : null;
+			const out = {};
+			for (const row of rows) {
+				if (wanted && !wanted.has(row.device_id)) continue;
+				if (!names.has(row.device_id)) continue;
+				const keys = await this.withSignatures(userId, `${row.device_id}`, row.keys);
+				const name = names.get(row.device_id);
+				keys.unsigned = {
+					...keys.unsigned,
+					...name ? { device_display_name: name } : {}
+				};
+				out[row.device_id] = keys;
+			}
+			result.device_keys[userId] = out;
+			const csRows = await this.hs.db.findMany("cross_signing_keys", { where: [{
+				field: "user_id",
+				value: userId
+			}] });
+			for (const cs of csRows) {
+				if (cs.key_type === "user_signing" && userId !== requester) continue;
+				const pub = Object.values(cs.key.keys ?? {})[0];
+				result[`${cs.key_type}_keys`][userId] = await this.withSignatures(userId, pub, cs.key);
+			}
+		}
+		if (Object.keys(remote).length && requester) {
+			const fetch = {};
+			const tracked = /* @__PURE__ */ new Set();
+			for (const [userId, devices] of Object.entries(remote)) {
+				if (!await this.isTracked(userId)) {
+					await this.dropRemoteCache(userId);
+					fetch[userId] = devices;
+					continue;
+				}
+				tracked.add(userId);
+				const list = await this.hs.db.findOne("remote_device_lists", [{
+					field: "user_id",
+					value: userId
+				}]);
+				if (!list || list.stale) {
+					fetch[userId] = [];
+					continue;
+				}
+				await this.fromRemoteCache(userId, devices, result);
+			}
+			if (Object.keys(fetch).length) {
+				const { results, failures } = await this.hs.federation.queryKeys(fetch, timeoutMs);
+				Object.assign(result.failures, failures);
+				const fetched = {
+					device_keys: {},
+					master_keys: {},
+					self_signing_keys: {}
+				};
+				for (const res of results) for (const kind of [
+					"device_keys",
+					"master_keys",
+					"self_signing_keys"
+				]) for (const [userId, value] of Object.entries(isObject(res[kind]) ? res[kind] : {})) if (fetch[userId] !== void 0) fetched[kind][userId] = value;
+				for (const userId of Object.keys(fetch)) {
+					if (tracked.has(userId) && isObject(fetched.device_keys[userId])) {
+						await this.storeRemoteCache(userId, fetched.device_keys[userId], fetched.master_keys[userId], fetched.self_signing_keys[userId]);
+						await this.fromRemoteCache(userId, remote[userId], result);
+						continue;
+					}
+					for (const kind of [
+						"device_keys",
+						"master_keys",
+						"self_signing_keys"
+					]) if (fetched[kind][userId] !== void 0) result[kind][userId] = fetched[kind][userId];
+				}
+			}
+		}
+		return result;
+	}
+	/** Whether a remote user shares a room with a local user (by known membership). */
+	async isTracked(userId) {
+		const rows = await this.hs.db.findMany("memberships", { where: [{
+			field: "user_id",
+			value: userId
+		}, {
+			field: "membership",
+			value: "join"
+		}] });
+		for (const row of rows) if ((await this.hs.rooms.joinedMembers(row.room_id)).some((u) => this.hs.isLocalUser(u))) return true;
+		return false;
+	}
+	async dropRemoteCache(userId) {
+		await this.hs.db.delete("remote_devices", [{
+			field: "user_id",
+			value: userId
+		}]);
+		await this.hs.db.delete("remote_device_lists", [{
+			field: "user_id",
+			value: userId
+		}]);
+	}
+	/** A tracked user's device list changed: refetch it on the next query. */
+	async markRemoteStale(userId) {
+		if (await this.isTracked(userId)) await this.hs.db.upsert("remote_device_lists", {
+			user_id: userId,
+			stream_id: 0,
+			stale: true
+		});
+		else await this.dropRemoteCache(userId);
+	}
+	async storeRemoteCache(userId, devices, master, selfSigning) {
+		await this.hs.db.delete("remote_devices", [{
+			field: "user_id",
+			value: userId
+		}]);
+		for (const [deviceId, keys] of Object.entries(devices)) {
+			if (!isObject(keys)) continue;
+			const name = keys.unsigned?.device_display_name;
+			await this.hs.db.upsert("remote_devices", {
+				user_id: userId,
+				device_id: deviceId,
+				keys,
+				display_name: typeof name === "string" ? name : null,
+				stream_id: 0
+			});
+		}
+		for (const [type, key] of [["master", master], ["self_signing", selfSigning]]) if (isObject(key)) await this.hs.streams.write((stream) => this.hs.db.upsert("cross_signing_keys", {
+			user_id: userId,
+			key_type: type,
+			key,
+			stream
+		}));
+		await this.hs.db.upsert("remote_device_lists", {
+			user_id: userId,
+			stream_id: 0,
+			stale: false
+		});
+	}
+	async fromRemoteCache(userId, devices, result) {
+		const wanted = Array.isArray(devices) && devices.length ? new Set(devices) : null;
+		const out = {};
+		for (const row of await this.hs.db.findMany("remote_devices", { where: [{
+			field: "user_id",
+			value: userId
+		}] })) if (!wanted || wanted.has(row.device_id)) out[row.device_id] = row.keys;
+		result.device_keys[userId] = out;
+		for (const cs of await this.hs.db.findMany("cross_signing_keys", { where: [{
+			field: "user_id",
+			value: userId
+		}] })) if (cs.key_type === "master" || cs.key_type === "self_signing") result[`${cs.key_type}_keys`][userId] = cs.key;
+	}
+	async withSignatures(userId, keyId, key) {
+		const sigs = await this.hs.db.findMany("key_signatures", { where: [{
+			field: "user_id",
+			value: userId
+		}, {
+			field: "key_id",
+			value: keyId
+		}] });
+		if (sigs.length === 0) return structuredClone(key);
+		const out = structuredClone(key);
+		out.signatures ??= {};
+		for (const s of sigs) out.signatures[s.signer] = {
+			...out.signatures[s.signer],
+			[s.signer_key_id]: s.signature
+		};
+		return out;
+	}
+	async claim(request) {
+		const result = {};
+		for (const [userId, devices] of Object.entries(request ?? {})) for (const [deviceId, algorithm] of Object.entries(devices ?? {})) {
+			const base = [
+				{
+					field: "user_id",
+					value: userId
+				},
+				{
+					field: "device_id",
+					value: deviceId
+				},
+				{
+					field: "algorithm",
+					value: algorithm
+				}
+			];
+			let key = (await this.hs.db.findMany("one_time_keys", {
+				where: [...base, {
+					field: "fallback",
+					value: false
+				}],
+				sortBy: {
+					field: "seq",
+					direction: "asc"
+				},
+				limit: 1
+			}))[0] ?? null;
+			if (key) await this.hs.db.delete("one_time_keys", [...base, {
+				field: "key_id",
+				value: key.key_id
+			}]);
+			else {
+				key = await this.hs.db.findOne("fallback_keys", base);
+				if (key && !key.used) await this.hs.db.update("fallback_keys", base, { used: true });
+			}
+			if (!key) continue;
+			result[userId] ??= {};
+			result[userId][deviceId] = { [key.key_id]: key.key };
+		}
+		return result;
+	}
+	async uploadCrossSigning(userId, body) {
+		for (const type of [
+			"master",
+			"self_signing",
+			"user_signing"
+		]) {
+			const key = body[`${type}_key`];
+			if (key === void 0) continue;
+			if (!isObject(key) || key.user_id !== userId || !isObject(key.keys)) throw errors.invalidParam(`Invalid ${type}_key`);
+			await this.hs.streams.write((stream) => this.hs.db.upsert("cross_signing_keys", {
+				user_id: userId,
+				key_type: type,
+				key,
+				stream
+			}));
+		}
+		await this.markDeviceListChanged(userId);
+		await this.hs.federation.onSigningKeyUpdate(userId).catch(() => {});
+	}
+	async uploadSignatures(signer, body) {
+		const failures = {};
+		const changed = /* @__PURE__ */ new Set();
+		for (const [userId, keys] of Object.entries(body ?? {})) {
+			if (!isObject(keys)) continue;
+			for (const [keyId, signed] of Object.entries(keys)) {
+				const sigs = signed?.signatures?.[signer];
+				if (!isObject(sigs)) {
+					failures[userId] = {
+						...failures[userId],
+						[keyId]: {
+							errcode: "M_INVALID_SIGNATURE",
+							error: "No signature from signer"
+						}
+					};
+					continue;
+				}
+				for (const [signerKeyId, signature] of Object.entries(sigs)) await this.hs.db.upsert("key_signatures", {
+					user_id: userId,
+					key_id: keyId,
+					signer,
+					signer_key_id: signerKeyId,
+					signature: String(signature)
+				});
+				changed.add(userId);
+			}
+		}
+		for (const u of changed) if (this.hs.isLocalUser(u)) await this.deviceChanged(u);
+		else await this.markDeviceListChanged(u);
+		if (changed.has(signer)) await this.hs.federation.onSigningKeyUpdate(signer).catch(() => {});
+		return { failures };
+	}
+	/** Users (sharing a room with `userId`) whose device lists changed after `since`. */
+	async changesSince(userId, since, upTo) {
+		const sharing = await this.hs.rooms.usersSharingRooms(userId);
+		const rows = await this.hs.db.findMany("device_list_changes", { where: [{
+			field: "stream",
+			operator: "gt",
+			value: since
+		}] });
+		const changed = /* @__PURE__ */ new Set();
+		for (const r of rows) if (r.stream <= upTo && sharing.has(r.user_id)) changed.add(r.user_id);
+		const left = /* @__PURE__ */ new Set();
+		const memberRows = await this.hs.db.findMany("memberships", { where: [{
+			field: "stream",
+			operator: "gt",
+			value: since
+		}] });
+		const myRooms = /* @__PURE__ */ new Set([...await this.hs.rooms.roomsForUser(userId), ...memberRows.filter((m) => m.user_id === userId).map((m) => m.room_id)]);
+		for (const m of memberRows) {
+			if (m.stream > upTo || !myRooms.has(m.room_id)) continue;
+			if (m.user_id === userId) {
+				const members = await this.hs.rooms.joinedMembers(m.room_id);
+				if (m.membership === "join") {
+					for (const u of members) if (u !== userId) changed.add(u);
+				} else for (const u of members) if (!sharing.has(u)) left.add(u);
+			} else if (m.membership === "join") changed.add(m.user_id);
+			else if (!sharing.has(m.user_id)) left.add(m.user_id);
+		}
+		for (const u of left) changed.delete(u);
+		return {
+			changed: [...changed],
+			left: [...left]
+		};
+	}
+};
+//#endregion
+export { KeyService };

package/dist/core/m.d.ts

@@ -0,0 +1,209 @@
+//#region src/core/m.d.ts
+export declare const M: {
+  readonly BEACON_INFO: "m.beacon_info";
+  readonly CALL: {
+    readonly INVITE: "m.call.invite";
+  };
+  readonly CHANGE_PASSWORD: "m.change_password";
+  readonly DEVICE_LIST_UPDATE: "m.device_list_update";
+  readonly DIRECT: "m.direct";
+  readonly DIRECT_TO_DEVICE: "m.direct_to_device";
+  readonly FEDERATE: "m.federate";
+  readonly FULLY_READ: "m.fully_read";
+  readonly GET_LOGIN_TOKEN: "m.get_login_token";
+  readonly HEROES: "m.heroes";
+  readonly HOMESERVER: "m.homeserver";
+  readonly ID: {
+    readonly PHONE: "m.id.phone";
+    readonly THIRDPARTY: "m.id.thirdparty";
+    readonly USER: "m.id.user";
+  };
+  readonly IGNORED_USER_LIST: "m.ignored_user_list";
+  readonly IN_REPLY_TO: "m.in_reply_to";
+  readonly INVITED_MEMBER_COUNT: "m.invited_member_count";
+  readonly JOINED_MEMBER_COUNT: "m.joined_member_count";
+  readonly LOGIN: {
+    readonly APPLICATION_SERVICE: "m.login.application_service";
+    readonly DUMMY: "m.login.dummy";
+    readonly EMAIL: {
+      readonly IDENTITY: "m.login.email.identity";
+    };
+    readonly MSISDN: "m.login.msisdn";
+    readonly PASSWORD: "m.login.password";
+    readonly REGISTRATION_TOKEN: "m.login.registration_token";
+    readonly SSO: "m.login.sso";
+    readonly TOKEN: "m.login.token";
+  };
+  readonly NOTICE: "m.notice";
+  readonly OAUTH: "m.oauth";
+  readonly POLL: {
+    readonly START: "m.poll.start";
+  };
+  readonly PRESENCE: "m.presence";
+  readonly PROFILE_FIELDS: "m.profile_fields";
+  readonly PUSH_RULES: "m.push_rules";
+  readonly REACTION: "m.reaction";
+  readonly READ: {
+    readonly _: "m.read";
+    readonly PRIVATE: "m.read.private";
+  };
+  readonly RECEIPT: "m.receipt";
+  readonly RELATES_TO: "m.relates_to";
+  readonly RELATIONS: "m.relations";
+  readonly RELATIONSHIP: "m.relationship";
+  readonly REPLACE: "m.replace";
+  readonly ROLE: {
+    readonly ADMIN: "m.role.admin";
+    readonly SECURITY: "m.role.security";
+  };
+  readonly ROOM: {
+    readonly ALIASES: "m.room.aliases";
+    readonly AVATAR: "m.room.avatar";
+    readonly CANONICAL_ALIAS: "m.room.canonical_alias";
+    readonly CREATE: "m.room.create";
+    readonly ENCRYPTED: "m.room.encrypted";
+    readonly ENCRYPTION: "m.room.encryption";
+    readonly GUEST_ACCESS: "m.room.guest_access";
+    readonly HISTORY_VISIBILITY: "m.room.history_visibility";
+    readonly JOIN_RULES: "m.room.join_rules";
+    readonly MEMBER: "m.room.member";
+    readonly MESSAGE: "m.room.message";
+    readonly NAME: "m.room.name";
+    readonly POLICY: "m.room.policy";
+    readonly POWER_LEVELS: "m.room.power_levels";
+    readonly REDACTION: "m.room.redaction";
+    readonly SERVER_ACL: "m.room.server_acl";
+    readonly THIRD_PARTY_INVITE: "m.room.third_party_invite";
+    readonly TOMBSTONE: "m.room.tombstone";
+    readonly TOPIC: "m.room.topic";
+  };
+  readonly ROOM_MEMBERSHIP: "m.room_membership";
+  readonly ROOM_VERSIONS: "m.room_versions";
+  readonly RULE: {
+    readonly CALL: ".m.rule.call";
+    readonly CONTAINS_DISPLAY_NAME: ".m.rule.contains_display_name";
+    readonly CONTAINS_USER_NAME: ".m.rule.contains_user_name";
+    readonly ENCRYPTED: ".m.rule.encrypted";
+    readonly ENCRYPTED_ROOM_ONE_TO_ONE: ".m.rule.encrypted_room_one_to_one";
+    readonly INVITE_FOR_ME: ".m.rule.invite_for_me";
+    readonly IS_ROOM_MENTION: ".m.rule.is_room_mention";
+    readonly IS_USER_MENTION: ".m.rule.is_user_mention";
+    readonly MASTER: ".m.rule.master";
+    readonly MEMBER_EVENT: ".m.rule.member_event";
+    readonly MESSAGE: ".m.rule.message";
+    readonly REACTION: ".m.rule.reaction";
+    readonly ROOM: {
+      readonly SERVER_ACL: ".m.rule.room.server_acl";
+    };
+    readonly ROOM_ONE_TO_ONE: ".m.rule.room_one_to_one";
+    readonly ROOMNOTIF: ".m.rule.roomnotif";
+    readonly SUPPRESS_EDITS: ".m.rule.suppress_edits";
+    readonly SUPPRESS_NOTICES: ".m.rule.suppress_notices";
+    readonly TOMBSTONE: ".m.rule.tombstone";
+  };
+  readonly SERVER: "m.server";
+  readonly SERVER_NOTICE: "m.server_notice";
+  readonly SET_AVATAR_URL: "m.set_avatar_url";
+  readonly SET_DISPLAYNAME: "m.set_displayname";
+  readonly SIGNING_KEY_UPDATE: "m.signing_key_update";
+  readonly SPACE: {
+    readonly _: "m.space";
+    readonly CHILD: "m.space.child";
+  };
+  readonly STICKER: "m.sticker";
+  readonly TAG: "m.tag";
+  readonly TEXT: "m.text";
+  readonly THREAD: "m.thread";
+  readonly THREEPID_CHANGES: "m.3pid_changes";
+  readonly TOPIC: "m.topic";
+  readonly TYPING: "m.typing";
+  readonly UPLOAD: {
+    readonly SIZE: "m.upload.size";
+  };
+};
+export declare const UNSTABLE: {
+  readonly DE: {
+    readonly SORUNOME: {
+      readonly MSC2409: {
+        readonly EPHEMERAL: "de.sorunome.msc2409.ephemeral";
+        readonly PUSH_EPHEMERAL: "de.sorunome.msc2409.push_ephemeral";
+      };
+    };
+  };
+  readonly IO: {
+    readonly ELEMENT: {
+      readonly MSC4306: {
+        readonly RULE: {
+          readonly SUBSCRIBED_THREAD: ".io.element.msc4306.rule.subscribed_thread";
+          readonly UNSUBSCRIBED_THREAD: ".io.element.msc4306.rule.unsubscribed_thread";
+        };
+        readonly THREAD_SUBSCRIPTION: "io.element.msc4306.thread_subscription";
+      };
+      readonly MSC4308: {
+        readonly THREAD_SUBSCRIPTIONS: "io.element.msc4308.thread_subscriptions";
+      };
+    };
+  };
+  readonly ORG: {
+    readonly MATRIX: {
+      readonly CROSS_SIGNING_RESET: "org.matrix.cross_signing_reset";
+      readonly CUSTOM: {
+        readonly HTML: "org.matrix.custom.html";
+      };
+      readonly MSC2732: {
+        readonly FALLBACK_KEYS: "org.matrix.msc2732.fallback_keys";
+      };
+      readonly MSC3202: {
+        readonly DEVICE_ID: "org.matrix.msc3202.device_id";
+      };
+      readonly MSC3381: {
+        readonly POLL: {
+          readonly END: "org.matrix.msc3381.poll.end";
+          readonly RESPONSE: "org.matrix.msc3381.poll.response";
+          readonly START: "org.matrix.msc3381.poll.start";
+        };
+      };
+      readonly MSC3874: {
+        readonly NOT_REL_TYPES: "org.matrix.msc3874.not_rel_types";
+        readonly REL_TYPES: "org.matrix.msc3874.rel_types";
+      };
+      readonly MSC3916: {
+        readonly STABLE: "org.matrix.msc3916.stable";
+      };
+      readonly MSC3930: {
+        readonly RULE: {
+          readonly POLL_END: ".org.matrix.msc3930.rule.poll_end";
+          readonly POLL_END_ONE_TO_ONE: ".org.matrix.msc3930.rule.poll_end_one_to_one";
+          readonly POLL_RESPONSE: ".org.matrix.msc3930.rule.poll_response";
+          readonly POLL_START: ".org.matrix.msc3930.rule.poll_start";
+          readonly POLL_START_ONE_TO_ONE: ".org.matrix.msc3930.rule.poll_start_one_to_one";
+        };
+      };
+      readonly MSC4140: {
+        readonly _: "org.matrix.msc4140";
+        readonly DELAY: "org.matrix.msc4140.delay";
+        readonly MAX_DELAY: "org.matrix.msc4140.max_delay";
+      };
+      readonly MSC4143: {
+        readonly _: "org.matrix.msc4143";
+        readonly RTC_FOCI: "org.matrix.msc4143.rtc_foci";
+      };
+      readonly MSC4155: {
+        readonly ERRCODE: "org.matrix.msc4155.errcode";
+        readonly INVITE_PERMISSION_CONFIG: "org.matrix.msc4155.invite_permission_config";
+      };
+      readonly MSC4222: {
+        readonly _: "org.matrix.msc4222";
+        readonly STATE_AFTER: "org.matrix.msc4222.state_after";
+        readonly USE_STATE_AFTER: "org.matrix.msc4222.use_state_after";
+      };
+      readonly MSC4306: "org.matrix.msc4306";
+      readonly MSC4429: {
+        readonly PROFILE_FIELDS: "org.matrix.msc4429.profile_fields";
+        readonly USERS: "org.matrix.msc4429.users";
+      };
+      readonly SIMPLIFIED_MSC3575: "org.matrix.simplified_msc3575";
+    };
+  };
+};
+//#endregion