@matrix-widget-toolkit/api 3.4.2 → 4.0.0

package/build/cjs/{index.js → index.cjs}

@@ -142,7 +142,7 @@ function isRoomEvent(event) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$4 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -151,7 +151,7 @@ var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator$3 = (undefined && undefined.__generator) || function (thisArg, body) {
+var __generator$4 = (undefined && undefined.__generator) || function (thisArg, body) {
     var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
     return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
     function verb(n) { return function (v) { return step([n, v]); }; }
@@ -192,10 +192,10 @@ var WIDGET_CAPABILITY_NAVIGATE = 'org.matrix.msc2931.navigate';
  * @param opts - {@link NavigateToRoomOptions}
  */
 function navigateToRoom(widgetApi_1, roomId_1) {
-    return __awaiter$3(this, arguments, void 0, function (widgetApi, roomId, opts) {
+    return __awaiter$4(this, arguments, void 0, function (widgetApi, roomId, opts) {
         var _a, via, params, url;
         if (opts === void 0) { opts = {}; }
-        return __generator$3(this, function (_b) {
+        return __generator$4(this, function (_b) {
             switch (_b.label) {
                 case 0:
                     _a = opts.via, via = _a === void 0 ? [] : _a;
@@ -439,7 +439,7 @@ function calculateActionPowerLevel(powerLevelStateEvent, action) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -448,7 +448,7 @@ var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator$2 = (undefined && undefined.__generator) || function (thisArg, body) {
+var __generator$3 = (undefined && undefined.__generator) || function (thisArg, body) {
     var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
     return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
     function verb(n) { return function (v) { return step([n, v]); }; }
@@ -498,9 +498,9 @@ function isValidRedactionEvent(event) {
  * @returns The redaction event that was send to the room.
  */
 function redactEvent(widgetApi, eventId) {
-    return __awaiter$2(this, void 0, void 0, function () {
+    return __awaiter$3(this, void 0, void 0, function () {
         var result;
-        return __generator$2(this, function (_a) {
+        return __generator$3(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, widgetApi.sendRoomEvent(ROOM_EVENT_REDACTION, { redacts: eventId })];
                 case 1:
@@ -765,7 +765,7 @@ var __assign = (undefined && undefined.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -774,7 +774,7 @@ var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator$1 = (undefined && undefined.__generator) || function (thisArg, body) {
+var __generator$2 = (undefined && undefined.__generator) || function (thisArg, body) {
     var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
     return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
     function verb(n) { return function (v) { return step([n, v]); }; }
@@ -873,10 +873,10 @@ var STATE_EVENT_WIDGETS = 'im.vector.modular.widgets';
  *                       registration, like the display name of the widget.
  */
 function repairWidgetRegistration(widgetApi_1) {
-    return __awaiter$1(this, arguments, void 0, function (widgetApi, registration) {
+    return __awaiter$2(this, arguments, void 0, function (widgetApi, registration) {
         var readResult, url, name, type, data;
         if (registration === void 0) { registration = {}; }
-        return __generator$1(this, function (_a) {
+        return __generator$2(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, widgetApi.requestCapabilities([
                         matrixWidgetApi.WidgetEventCapability.forStateEvent(matrixWidgetApi.EventDirection.Send, STATE_EVENT_WIDGETS, widgetApi.widgetId),
@@ -938,6 +938,42 @@ function repairWidgetRegistration(widgetApi_1) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator$1 = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 function convertToRawCapabilities(rawCapabilities) {
     return rawCapabilities.map(function (c) { return (typeof c === 'string' ? c : c.raw); });
 }
@@ -964,6 +1000,47 @@ function isInRoom(matrixEvent, currentRoomId, roomIds) {
     }
     return roomIds.includes(matrixEvent.room_id);
 }
+/**
+ * Create a state event from the arguments.
+ *
+ * @returns A state event with current timestamp origin_server_ts.
+ */
+function makeEventFromSendStateEventResult(type, stateKey, content, sender, sendResult) {
+    if (sendResult.event_id === undefined) {
+        throw new Error('Send state event did not return an event ID');
+    }
+    return {
+        content: content,
+        event_id: sendResult.event_id,
+        origin_server_ts: Date.now(),
+        room_id: sendResult.room_id,
+        sender: sender,
+        state_key: stateKey,
+        type: type,
+    };
+}
+/**
+ * Send a state event and resolve to a "virtual" state event.
+ *
+ * @returns Promise, that resolves to a state event with current timestamp origin_server_ts.
+ */
+function sendStateEventWithEventResult(widgetApi, type, stateKey, content) {
+    return __awaiter$1(this, void 0, void 0, function () {
+        var response;
+        return __generator$1(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (widgetApi.widgetParameters.userId === undefined) {
+                        throw new Error('Own user ID is undefined');
+                    }
+                    return [4 /*yield*/, widgetApi.sendStateEvent(type, content, { stateKey: stateKey })];
+                case 1:
+                    response = _a.sent();
+                    return [2 /*return*/, makeEventFromSendStateEventResult(type, stateKey, content, widgetApi.widgetParameters.userId, response)];
+            }
+        });
+    });
+}
 
 /*
  * Copyright 2022 Nordeck IT + Consulting GmbH
@@ -1334,36 +1411,9 @@ var WidgetApiImpl = /** @class */ (function () {
         return rxjs.concat(historyEvent$, futureEvent$);
     };
     /** {@inheritDoc WidgetApi.sendStateEvent} */
-    WidgetApiImpl.prototype.sendStateEvent = function (eventType_1, content_1) {
-        return __awaiter(this, arguments, void 0, function (eventType, content, _a) {
-            var subject, subscription, _b, event_id_1, room_id_1, event_1;
-            var _c = _a === void 0 ? {} : _a, roomId = _c.roomId, _d = _c.stateKey, stateKey = _d === void 0 ? '' : _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        subject = new rxjs.ReplaySubject();
-                        subscription = this.events$.subscribe(function (e) { return subject.next(e); });
-                        _e.label = 1;
-                    case 1:
-                        _e.trys.push([1, , 4, 5]);
-                        return [4 /*yield*/, this.matrixWidgetApi.sendStateEvent(eventType, stateKey, content, roomId)];
-                    case 2:
-                        _b = _e.sent(), event_id_1 = _b.event_id, room_id_1 = _b.room_id;
-                        return [4 /*yield*/, rxjs.firstValueFrom(subject.pipe(rxjs.filter(function (event) {
-                                var matrixEvent = event.detail.data;
-                                return (matrixEvent.event_id === event_id_1 &&
-                                    matrixEvent.room_id === room_id_1);
-                            }), rxjs.map(function (event) { return event.detail.data; })))];
-                    case 3:
-                        event_1 = _e.sent();
-                        return [2 /*return*/, event_1];
-                    case 4:
-                        subscription.unsubscribe();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
+    WidgetApiImpl.prototype.sendStateEvent = function (eventType, content, _a) {
+        var _b = _a === void 0 ? {} : _a, roomId = _b.roomId, _c = _b.stateKey, stateKey = _c === void 0 ? '' : _c;
+        return this.matrixWidgetApi.sendStateEvent(eventType, stateKey, content, roomId);
     };
     /** {@inheritDoc WidgetApi.receiveRoomEvents} */
     WidgetApiImpl.prototype.receiveRoomEvents = function (eventType_1) {
@@ -1400,7 +1450,7 @@ var WidgetApiImpl = /** @class */ (function () {
     /** {@inheritDoc WidgetApi.sendRoomEvent} */
     WidgetApiImpl.prototype.sendRoomEvent = function (eventType_1, content_1) {
         return __awaiter(this, arguments, void 0, function (eventType, content, _a) {
-            var subject, subscription, _b, event_id_2, room_id_2, event_2;
+            var subject, subscription, _b, event_id_1, room_id_1, event_1;
             var _c = _a === void 0 ? {} : _a, roomId = _c.roomId;
             return __generator(this, function (_d) {
                 switch (_d.label) {
@@ -1412,15 +1462,15 @@ var WidgetApiImpl = /** @class */ (function () {
                         _d.trys.push([1, , 4, 5]);
                         return [4 /*yield*/, this.matrixWidgetApi.sendRoomEvent(eventType, content, roomId)];
                     case 2:
-                        _b = _d.sent(), event_id_2 = _b.event_id, room_id_2 = _b.room_id;
+                        _b = _d.sent(), event_id_1 = _b.event_id, room_id_1 = _b.room_id;
                         return [4 /*yield*/, rxjs.firstValueFrom(subject.pipe(rxjs.filter(function (event) {
                                 var matrixEvent = event.detail.data;
-                                return (matrixEvent.event_id === event_id_2 &&
-                                    matrixEvent.room_id === room_id_2);
+                                return (matrixEvent.event_id === event_id_1 &&
+                                    matrixEvent.room_id === room_id_1);
                             }), rxjs.map(function (event) { return event.detail.data; })))];
                     case 3:
-                        event_2 = _d.sent();
-                        return [2 /*return*/, event_2];
+                        event_1 = _d.sent();
+                        return [2 /*return*/, event_1];
                     case 4:
                         subscription.unsubscribe();
                         return [7 /*endfinally*/];
@@ -1721,8 +1771,10 @@ exports.isValidEventWithRelatesTo = isValidEventWithRelatesTo;
 exports.isValidPowerLevelStateEvent = isValidPowerLevelStateEvent;
 exports.isValidRedactionEvent = isValidRedactionEvent;
 exports.isValidRoomMemberStateEvent = isValidRoomMemberStateEvent;
+exports.makeEventFromSendStateEventResult = makeEventFromSendStateEventResult;
 exports.navigateToRoom = navigateToRoom;
 exports.observeRedactionEvents = observeRedactionEvents;
 exports.parseWidgetId = parseWidgetId;
 exports.redactEvent = redactEvent;
 exports.repairWidgetRegistration = repairWidgetRegistration;
+exports.sendStateEventWithEventResult = sendStateEventWithEventResult;

package/build/cjs/index.d.cts

@@ -0,0 +1,5 @@
+/**
+ * @packageDocumentation This is package that wraps `matrix-widget-api` to
+ *                       provide a more convenient API.
+ */
+export * from './api';

package/build/esm/api/WidgetApiImpl.d.ts

@@ -0,0 +1,179 @@
+import { Capability, IDownloadFileActionFromWidgetResponseData, IGetMediaConfigActionFromWidgetResponseData, IModalWidgetCreateData, IModalWidgetOpenRequestDataButton, IModalWidgetReturnData, IOpenIDCredentials, ISendEventFromWidgetResponseData, IUploadFileActionFromWidgetResponseData, IWidgetApiRequestData, WidgetApi as MatrixWidgetApi, ModalButtonID, Symbols, WidgetEventCapability } from 'matrix-widget-api';
+import { Observable } from 'rxjs';
+import { RoomEvent, StateEvent, ToDeviceMessageEvent, TurnServer, WidgetApi, WidgetConfig, WidgetParameters } from './types';
+/**
+ * Options for the {@link WidgetApiImpl.create} function.
+ */
+export type WidgetApiOptions = {
+    /**
+     * Optional initial capabilities that should be requested from the user on
+     * load.
+     */
+    capabilities?: Array<WidgetEventCapability | Capability>;
+    /**
+     * Enable the the pop-out button for pinned widgets that support running
+     * without the Widget API.
+     */
+    supportStandalone?: boolean;
+};
+/**
+ * Implementation of the API from the widget to the client.
+ *
+ * @remarks Widget API is specified here:
+ * https://docs.google.com/document/d/1uPF7XWY_dXTKVKV7jZQ2KmsI19wn9-kFRgQ1tFQP7wQ/edit#heading=h.9rn9lt6ctkgi
+ */
+export declare class WidgetApiImpl implements WidgetApi {
+    /**
+     * Provide access to the underlying widget API from `matrix-widget-sdk`.
+     *
+     * @remarks Normally there is no need to use it, however if features are
+     *          missing from `WidgetApi` it can be handy to work with the
+     *          original API.
+     */
+    readonly matrixWidgetApi: MatrixWidgetApi;
+    /** {@inheritDoc WidgetApi.widgetId} */
+    readonly widgetId: string;
+    /** {@inheritDoc WidgetApi.widgetParameters} */
+    readonly widgetParameters: WidgetParameters;
+    /**
+     * Initialize a new widget API instance and wait till it is ready.
+     * There should only be one instance of the widget API. The widget API should
+     * be created as early as possible when starting the application. This is
+     * required to match the timing of the API connection establishment with the
+     * client, especially in Safari. Therefore it is recommended to create it
+     * inside the entrypoint, before initializing rendering engines like react.
+     *
+     * @param param0 - {@link WidgetApiOptions}
+     *
+     * @returns A widget API instance ready to use.
+     */
+    static create({ capabilities, supportStandalone, }?: WidgetApiOptions): Promise<WidgetApi>;
+    private widgetConfig;
+    private outstandingCapabilitiesRequest;
+    private outstandingOpenIDConnectTokenRequest;
+    private cachedOpenIdToken;
+    private readonly events$;
+    private readonly toDeviceMessages$;
+    private readonly initialCapabilities;
+    constructor(
+    /**
+     * Provide access to the underlying widget API from `matrix-widget-sdk`.
+     *
+     * @remarks Normally there is no need to use it, however if features are
+     *          missing from `WidgetApi` it can be handy to work with the
+     *          original API.
+     */
+    matrixWidgetApi: MatrixWidgetApi, 
+    /** {@inheritDoc WidgetApi.widgetId} */
+    widgetId: string, 
+    /** {@inheritDoc WidgetApi.widgetParameters} */
+    widgetParameters: WidgetParameters, { capabilities, supportStandalone }?: WidgetApiOptions);
+    /**
+     * Initialize the widget API and wait till a connection with the client is
+     * fully established.
+     *
+     * Waits till the user has approved the initial set of capabilities. The
+     * method doesn't fail if the user doesn't approve all of them. It is
+     * required to check manually afterwards.
+     * In case of modal widgets it waits till the `widgetConfig` is received.
+     *
+     * @remarks Should only be called once during startup.
+     */
+    initialize(): Promise<void>;
+    /** {@inheritDoc WidgetApi.getWidgetConfig} */
+    getWidgetConfig<T extends IWidgetApiRequestData>(): Readonly<WidgetConfig<T> | undefined>;
+    /** {@inheritDoc WidgetApi.rerequestInitialCapabilities} */
+    rerequestInitialCapabilities(): Promise<void>;
+    /** {@inheritDoc WidgetApi.hasInitialCapabilities} */
+    hasInitialCapabilities(): boolean;
+    /** {@inheritDoc WidgetApi.requestCapabilities} */
+    requestCapabilities(capabilities: Array<WidgetEventCapability | Capability>): Promise<void>;
+    private requestCapabilitiesInternal;
+    /** {@inheritDoc WidgetApi.hasCapabilities} */
+    hasCapabilities(capabilities: Array<WidgetEventCapability | Capability>): boolean;
+    /** {@inheritDoc WidgetApi.receiveSingleStateEvent} */
+    receiveSingleStateEvent<T>(eventType: string, stateKey?: string): Promise<StateEvent<T> | undefined>;
+    /** {@inheritDoc WidgetApi.receiveStateEvents} */
+    receiveStateEvents<T>(eventType: string, { stateKey, roomIds, }?: {
+        stateKey?: string;
+        roomIds?: string[] | Symbols.AnyRoom;
+    }): Promise<StateEvent<T>[]>;
+    /** {@inheritDoc WidgetApi.observeStateEvents} */
+    observeStateEvents<T>(eventType: string, { stateKey, roomIds, }?: {
+        stateKey?: string;
+        roomIds?: string[] | Symbols.AnyRoom;
+    }): Observable<StateEvent<T>>;
+    /** {@inheritDoc WidgetApi.sendStateEvent} */
+    sendStateEvent<T>(eventType: string, content: T, { roomId, stateKey }?: {
+        roomId?: string;
+        stateKey?: string;
+    }): Promise<ISendEventFromWidgetResponseData>;
+    /** {@inheritDoc WidgetApi.receiveRoomEvents} */
+    receiveRoomEvents<T>(eventType: string, { messageType, roomIds, }?: {
+        messageType?: string;
+        roomIds?: string[] | Symbols.AnyRoom;
+    }): Promise<Array<RoomEvent<T>>>;
+    /** {@inheritDoc WidgetApi.observeRoomEvents} */
+    observeRoomEvents<T>(eventType: string, { messageType, roomIds, }?: {
+        messageType?: string;
+        roomIds?: string[] | Symbols.AnyRoom;
+    }): Observable<RoomEvent<T>>;
+    /** {@inheritDoc WidgetApi.sendRoomEvent} */
+    sendRoomEvent<T>(eventType: string, content: T, { roomId }?: {
+        roomId?: string;
+    }): Promise<RoomEvent<T>>;
+    /** {@inheritDoc WidgetApi.readEventRelations} */
+    readEventRelations(eventId: string, options?: {
+        roomId?: string;
+        limit?: number;
+        from?: string;
+        relationType?: string;
+        eventType?: string;
+        direction?: 'f' | 'b';
+    }): Promise<{
+        chunk: Array<RoomEvent | StateEvent>;
+        nextToken?: string;
+    }>;
+    /** {@inheritDoc WidgetApi.sendToDeviceMessage} */
+    sendToDeviceMessage<T>(eventType: string, encrypted: boolean, content: {
+        [userId: string]: {
+            [deviceId: string | '*']: T;
+        };
+    }): Promise<void>;
+    /** {@inheritDoc WidgetApi.observeToDeviceMessages} */
+    observeToDeviceMessages<T>(eventType: string): Observable<ToDeviceMessageEvent<T>>;
+    /** {@inheritDoc WidgetApi.openModal} */
+    openModal<T extends Record<string, unknown> = Record<string, unknown>, U extends IModalWidgetCreateData = IModalWidgetCreateData>(pathName: string, name: string, options?: {
+        buttons?: IModalWidgetOpenRequestDataButton[];
+        data?: U;
+    }): Promise<T | undefined>;
+    /** {@inheritDoc WidgetApi.setModalButtonEnabled} */
+    setModalButtonEnabled(buttonId: ModalButtonID, isEnabled: boolean): Promise<void>;
+    /** {@inheritDoc WidgetApi.observeModalButtons} */
+    observeModalButtons(): Observable<ModalButtonID>;
+    /** {@inheritDoc WidgetApi.closeModal} */
+    closeModal<T extends IModalWidgetReturnData>(data?: T): Promise<void>;
+    /** {@inheritdoc WidgetApi.navigateTo} */
+    navigateTo(uri: string): Promise<void>;
+    /** {@inheritdoc WidgetApi.requestOpenIDConnectToken} */
+    requestOpenIDConnectToken(): Promise<IOpenIDCredentials>;
+    private requestOpenIDConnectTokenInternal;
+    /** {@inheritdoc WidgetApi.observeTurnServers} */
+    observeTurnServers(): Observable<TurnServer>;
+    /** {@inheritdoc WidgetApi.searchUserDirectory}  */
+    searchUserDirectory(searchTerm: string, options?: {
+        limit?: number | undefined;
+    } | undefined): Promise<{
+        results: Array<{
+            userId: string;
+            displayName?: string;
+            avatarUrl?: string;
+        }>;
+    }>;
+    /** {@inheritdoc WidgetApi.getMediaConfig}  */
+    getMediaConfig(): Promise<IGetMediaConfigActionFromWidgetResponseData>;
+    /** {@inheritdoc WidgetApi.uploadFile}  */
+    uploadFile(file: XMLHttpRequestBodyInit): Promise<IUploadFileActionFromWidgetResponseData>;
+    /** {@inheritdoc WidgetApi.downloadFile}  */
+    downloadFile(contentUrl: string): Promise<IDownloadFileActionFromWidgetResponseData>;
+}

package/build/esm/api/WidgetApiImpl.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/api/extras/capabilities.d.ts

@@ -0,0 +1,12 @@
+import { Symbols } from 'matrix-widget-api';
+/**
+ * Generate a list of capabilities to access the timeline of other rooms.
+ * If enabled, all previously or future capabilities will apply to _all_
+ * selected rooms.
+ * If `Symbols.AnyRoom` is passed, this is expanded to all joined
+ * or invited rooms the client is able to see, current and future.
+ *
+ * @param roomIds - a list of room ids or `@link Symbols.AnyRoom`.
+ * @returns the generated capabilities.
+ */
+export declare function generateRoomTimelineCapabilities(roomIds: string[] | Symbols.AnyRoom): string[];

package/build/esm/api/extras/capabilities.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/api/extras/displayName.d.ts

@@ -0,0 +1,12 @@
+import { StateEvent } from '../types';
+import { RoomMemberStateEventContent } from './roomMember';
+/**
+ * Generate a unique displayname of a user that is consistent across Matrix clients.
+ *
+ * @remarks The algorithm is based on https://spec.matrix.org/v1.1/client-server-api/#calculating-the-display-name-for-a-user
+ *
+ * @param member - the member to generate a name for.
+ * @param allRoomMembers - a list of all members of the same room.
+ * @returns the displayname that is unique in given the set of all room members.
+ */
+export declare function getRoomMemberDisplayName(member: StateEvent<RoomMemberStateEventContent>, allRoomMembers?: StateEvent<RoomMemberStateEventContent>[]): string;

package/build/esm/api/extras/displayName.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/api/extras/events.d.ts

@@ -0,0 +1,15 @@
+import { RoomEvent, StateEvent } from '../types';
+/**
+ * Check if the given event is a {@link StateEvent}.
+ *
+ * @param event - An event that is either a {@link RoomEvent} or a {@link StateEvent}.
+ * @returns True, if the event is a {@link StateEvent}.
+ */
+export declare function isStateEvent(event: RoomEvent | StateEvent): event is StateEvent;
+/**
+ * Check if the given event is a {@link RoomEvent}.
+ *
+ * @param event - An event that is either a {@link RoomEvent} or a {@link StateEvent}.
+ * @returns True, if the event is a {@link RoomEvent}.
+ */
+export declare function isRoomEvent(event: RoomEvent | StateEvent): event is RoomEvent;

package/build/esm/api/extras/events.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/api/extras/index.d.ts

@@ -0,0 +1,14 @@
+export { generateRoomTimelineCapabilities } from './capabilities';
+export { getRoomMemberDisplayName } from './displayName';
+export { isRoomEvent, isStateEvent } from './events';
+export { WIDGET_CAPABILITY_NAVIGATE, navigateToRoom } from './navigateTo';
+export type { NavigateToRoomOptions } from './navigateTo';
+export { compareOriginServerTS } from './originServerTs';
+export { STATE_EVENT_POWER_LEVELS, calculateUserPowerLevel, hasActionPower, hasRoomEventPower, hasStateEventPower, isValidPowerLevelStateEvent, } from './powerLevel';
+export type { PowerLevelsActions, PowerLevelsStateEvent } from './powerLevel';
+export { ROOM_EVENT_REDACTION, isValidRedactionEvent, observeRedactionEvents, redactEvent, } from './redactions';
+export type { Redaction, RedactionRoomEvent } from './redactions';
+export { getContent, getOriginalEventId, isValidEventWithRelatesTo, } from './relatesTo';
+export type { EventWithRelatesTo, NewContentRelatesTo, RelatesTo, RoomEventOrNewContent, } from './relatesTo';
+export { STATE_EVENT_ROOM_MEMBER, isValidRoomMemberStateEvent, } from './roomMember';
+export type { MembershipState, RoomMemberStateEventContent, } from './roomMember';

package/build/esm/api/extras/navigateTo.d.ts

@@ -0,0 +1,24 @@
+import { WidgetApi } from '../types';
+/**
+ * The capability that needs to be requested in order to navigate to another room.
+ */
+export declare const WIDGET_CAPABILITY_NAVIGATE = "org.matrix.msc2931.navigate";
+/**
+ * Options for the {@link navigateToRoom} function.
+ */
+export type NavigateToRoomOptions = {
+    /**
+     * Optional, array of one or more homeserver domains to discover the room.
+     */
+    via?: string[];
+};
+/**
+ * Navigate the client to another matrix room.
+ *
+ * @remarks This requires the {@link WIDGET_CAPABILITY_NAVIGATE} capability.
+ *
+ * @param widgetApi - the {@link WidgetApi} instance.
+ * @param roomId - the room ID.
+ * @param opts - {@link NavigateToRoomOptions}
+ */
+export declare function navigateToRoom(widgetApi: WidgetApi, roomId: string, opts?: NavigateToRoomOptions): Promise<void>;

package/build/esm/api/extras/navigateTo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/api/extras/originServerTs.d.ts

@@ -0,0 +1,10 @@
+import { RoomEvent } from '../types';
+/**
+ * Compares two room events by their origin server timestamp.
+ *
+ * @param a - A room event
+ * @param b - A room event
+ * @returns Either zero if the timestamp is equal, \>0 if a is newer, or \<0 if
+ *          b is newer.
+ */
+export declare function compareOriginServerTS<T>(a: RoomEvent<T>, b: RoomEvent<T>): number;

package/build/esm/api/extras/originServerTs.test.d.ts

@@ -0,0 +1 @@
+export {};