@matrix-widget-toolkit/api 3.4.2 → 4.0.0

package/build/cjs/api/WidgetApiImpl.d.cts

@@ -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/cjs/api/WidgetApiImpl.test.d.cts

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

package/build/cjs/api/extras/capabilities.d.cts

@@ -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/cjs/api/extras/capabilities.test.d.cts

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

package/build/cjs/api/extras/displayName.d.cts

@@ -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/cjs/api/extras/displayName.test.d.cts

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

package/build/cjs/api/extras/events.d.cts

@@ -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/cjs/api/extras/events.test.d.cts

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

package/build/cjs/api/extras/index.d.cts

@@ -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/cjs/api/extras/navigateTo.d.cts

@@ -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/cjs/api/extras/navigateTo.test.d.cts

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

package/build/cjs/api/extras/originServerTs.d.cts

@@ -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/cjs/api/extras/originServerTs.test.d.cts

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

package/build/cjs/api/extras/powerLevel.d.cts

@@ -0,0 +1,105 @@
+import { StateEvent } from '../types';
+/**
+ * The name of the power levels state event.
+ */
+export declare const STATE_EVENT_POWER_LEVELS = "m.room.power_levels";
+/**
+ * The types of actions.
+ */
+export type PowerLevelsActions = 'invite' | 'kick' | 'ban' | 'redact';
+/**
+ * The content of an `m.room.power_levels` event.
+ */
+export type PowerLevelsStateEvent = {
+    events?: {
+        [key: string]: number;
+    };
+    state_default?: number;
+    events_default?: number;
+    users?: {
+        [key: string]: number;
+    };
+    users_default?: number;
+    ban?: number;
+    invite?: number;
+    kick?: number;
+    redact?: number;
+};
+/**
+ * Validates that `event` is has a valid structure for a
+ * {@link PowerLevelsStateEvent}.
+ * @param event - The event to validate.
+ * @returns True, if the event is valid.
+ */
+export declare function isValidPowerLevelStateEvent(event: StateEvent<unknown>): event is StateEvent<PowerLevelsStateEvent>;
+/**
+ * Check if a user has the power to send a specific room event.
+ *
+ * @param powerLevelStateEvent - the content of the `m.room.power_levels` event
+ * @param userId - the id of the user
+ * @param eventType - the type of room event
+ * @returns if true, the user has the power
+ */
+export declare function hasRoomEventPower(powerLevelStateEvent: PowerLevelsStateEvent | undefined, userId: string | undefined, eventType: string): boolean;
+/**
+ * Check if a user has the power to send a specific state event.
+ *
+ * @param powerLevelStateEvent - the content of the `m.room.power_levels` event
+ * @param userId - the id of the user
+ * @param eventType - the type of state event
+ * @returns if true, the user has the power
+ */
+export declare function hasStateEventPower(powerLevelStateEvent: PowerLevelsStateEvent | undefined, userId: string | undefined, eventType: string): boolean;
+/**
+ * Check if a user has the power to perform a specific action.
+ *
+ * Supported actions:
+ *   * invite: Invite a new user into the room
+ *   * kick: Kick a user from the room
+ *   * ban: Ban a user from the room
+ *   * redact: Redact a message from another user
+ *
+ * @param powerLevelStateEvent - the content of the `m.room.power_levels` event
+ * @param userId - the id of the user
+ * @param action - the action
+ * @returns if true, the user has the power
+ */
+export declare function hasActionPower(powerLevelStateEvent: PowerLevelsStateEvent | undefined, userId: string | undefined, action: PowerLevelsActions): boolean;
+/**
+ * Calculate the power level of the user based on a `m.room.power_levels` event.
+ *
+ * @param powerLevelStateEvent - the content of the `m.room.power_levels` event.
+ * @param userId - the ID of the user.
+ * @returns the power level of the user.
+ */
+export declare function calculateUserPowerLevel(powerLevelStateEvent: PowerLevelsStateEvent, userId?: string): number;
+/**
+ * Calculate the power level that a user needs send a specific room event.
+ *
+ * @param powerLevelStateEvent - the content of the `m.room.power_levels` event
+ * @param eventType - the type of room event
+ * @returns the power level that is needed
+ */
+export declare function calculateRoomEventPowerLevel(powerLevelStateEvent: PowerLevelsStateEvent, eventType: string): number;
+/**
+ * Calculate the power level that a user needs send a specific state event.
+ *
+ * @param powerLevelStateEvent - the content of the `m.room.power_levels` event
+ * @param eventType - the type of state event
+ * @returns the power level that is needed
+ */
+export declare function calculateStateEventPowerLevel(powerLevelStateEvent: PowerLevelsStateEvent, eventType: string): number;
+/**
+ * Calculate the power level that a user needs to perform an action.
+ *
+ * Supported actions:
+ *   * invite: Invite a new user into the room
+ *   * kick: Kick a user from the room
+ *   * ban: Ban a user from the room
+ *   * redact: Redact a message from another user
+ *
+ * @param powerLevelStateEvent - the content of the `m.room.power_levels` event
+ * @param action - the action
+ * @returns the power level that is needed
+ */
+export declare function calculateActionPowerLevel(powerLevelStateEvent: PowerLevelsStateEvent, action: PowerLevelsActions): number;

package/build/cjs/api/extras/powerLevel.test.d.cts

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

package/build/cjs/api/extras/redactions.d.cts

@@ -0,0 +1,42 @@
+import { Observable } from 'rxjs';
+import { RoomEvent, WidgetApi } from '../types';
+/**
+ * The name of the redaction room event.
+ */
+export declare const ROOM_EVENT_REDACTION = "m.room.redaction";
+/**
+ * The content of an `m.room.redaction` event.
+ */
+export type Redaction = {
+    /**
+     * The id of the event that is redacted.
+     */
+    redacts: string;
+};
+/**
+ * Types a {@link RoomEvent} to include the properties of a redaction.
+ *
+ * @remarks The redaction event is a special snowflake. The actual data is
+ *          outside the content to make it readable without having to decrypt
+ *          it.
+ */
+export type RedactionRoomEvent = RoomEvent<Record<string, never>> & Redaction;
+/**
+ * Check whether the format of a redaction event is valid.
+ * @param event - The event to check.
+ * @returns True if the event format is valid, otherwise false.
+ */
+export declare function isValidRedactionEvent(event: RoomEvent<unknown>): event is RedactionRoomEvent;
+/**
+ * Redacts an event in the current room.
+ * @param widgetApi - An instance of the widget API.
+ * @param eventId - The id of the event to redact.
+ * @returns The redaction event that was send to the room.
+ */
+export declare function redactEvent(widgetApi: WidgetApi, eventId: string): Promise<RedactionRoomEvent>;
+/**
+ * Observes redaction events in the current room.
+ * @param widgetApi - An instance of the widget API.
+ * @returns An observable of validated redaction events.
+ */
+export declare function observeRedactionEvents(widgetApi: WidgetApi): Observable<RedactionRoomEvent>;

package/build/cjs/api/extras/redactions.test.d.cts

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

package/build/cjs/api/extras/relatesTo.d.cts

@@ -0,0 +1,60 @@
+import { RoomEvent } from '../types';
+/**
+ * Defines a relation to another event.
+ */
+export type RelatesTo<RelationType extends string> = {
+    /**
+     * The event id of the other event.
+     */
+    event_id: string;
+    /**
+     * The relation to the other event.
+     */
+    rel_type: RelationType;
+};
+/**
+ * Content of a room event that relates to another event.
+ */
+export type EventWithRelatesTo<RelationType extends string> = RoomEvent<{
+    /**
+     * A reference to the event that it relates to.
+     */
+    'm.relates_to': RelatesTo<RelationType>;
+}>;
+/**
+ * Content of a room event that replaces an existing event with
+ * the "m.replace" relation, which means that the content of the
+ * previous event is fully replaced.
+ */
+export type NewContentRelatesTo<T> = EventWithRelatesTo<'m.replace'>['content'] & {
+    /**
+     * The new content of the event.
+     */
+    'm.new_content': T;
+};
+/**
+ * A room event that either contains the content directly or contains an
+ * "m.new_content" object.
+ */
+export type RoomEventOrNewContent<T = unknown> = RoomEvent<T | NewContentRelatesTo<T>>;
+/**
+ * Get the original event id, or the event id of the current event if it
+ * doesn't relates to another event.
+ * @param event - The room event.
+ * @returns The event id of the original event, or the current event id.
+ */
+export declare function getOriginalEventId<T>(event: RoomEventOrNewContent<T>): string;
+/**
+ * Get the content of the event, independent from whether it contains the
+ * content directly or contains a "m.new_content" key.
+ * @param event - The room event.
+ * @returns Only the content of the room event.
+ */
+export declare function getContent<T>(event: RoomEventOrNewContent<T>): T;
+/**
+ * Validates that `event` has a valid structure for a
+ * {@link EventWithRelatesTo}.
+ * @param event - The event to validate.
+ * @returns True, if the event is valid.
+ */
+export declare function isValidEventWithRelatesTo(event: RoomEvent): event is EventWithRelatesTo<string>;

package/build/cjs/api/extras/relatesTo.test.d.cts

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

package/build/cjs/api/extras/roomMember.d.cts

@@ -0,0 +1,35 @@
+import { StateEvent } from '../types';
+/**
+ * The name of the room member state event.
+ */
+export declare const STATE_EVENT_ROOM_MEMBER = "m.room.member";
+/**
+ * The membership state of a user.
+ */
+export type MembershipState = 'join' | 'invite' | 'leave' | 'ban' | 'knock';
+/**
+ * The content of an `m.room.member` event.
+ *
+ * @remarks based on https://github.com/matrix-org/matrix-spec/blob/main/data/event-schemas/schema/m.room.member.yaml
+ */
+export type RoomMemberStateEventContent = {
+    /**
+     * The membership state of the user.
+     */
+    membership: MembershipState;
+    /**
+     * The display name for this user, if any.
+     */
+    displayname?: string | null;
+    /**
+     * The avatar URL for this user, if any.
+     */
+    avatar_url?: string | null;
+};
+/**
+ * Validates that `event` is has a valid structure for a
+ * {@link RoomMemberStateEventContent}.
+ * @param event - The event to validate.
+ * @returns True, if the event is valid.
+ */
+export declare function isValidRoomMemberStateEvent(event: StateEvent<unknown>): event is StateEvent<RoomMemberStateEventContent>;

package/build/cjs/api/extras/roomMember.test.d.cts

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

package/build/cjs/api/index.d.cts

@@ -0,0 +1,8 @@
+export * from './extras';
+export { extractRawWidgetParameters, extractWidgetApiParameters, extractWidgetParameters, parseWidgetId, } from './parameters';
+export type { WidgetApiParameters, WidgetId } from './parameters';
+export { generateWidgetRegistrationUrl, hasRequiredWidgetParameters, repairWidgetRegistration, } from './registration';
+export type { RoomEvent, StateEvent, ToDeviceMessageEvent, TurnServer, WidgetApi, WidgetConfig, WidgetParameters, WidgetRegistration, } from './types';
+export { makeEventFromSendStateEventResult, sendStateEventWithEventResult, } from './utils';
+export { WidgetApiImpl } from './WidgetApiImpl';
+export type { WidgetApiOptions } from './WidgetApiImpl';

package/build/cjs/api/parameters.d.cts

@@ -0,0 +1,58 @@
+import { WidgetParameters } from './types';
+/**
+ * Parameters used to initialize the widget API inside the widget.
+ */
+export type WidgetApiParameters = {
+    /**
+     * The id of the widget.
+     */
+    widgetId: string;
+    /**
+     * The origin of the client.
+     */
+    clientOrigin: string;
+};
+/**
+ * Extract the parameters used to initialize the widget API from the current
+ * `window.location`.
+ * @returns The parameters required for initializing the widget API.
+ */
+export declare function extractWidgetApiParameters(): WidgetApiParameters;
+/**
+ * Extract the widget parameters from the current `window.location`.
+ * @returns The all unprocessed raw widget parameters.
+ */
+export declare function extractRawWidgetParameters(): Record<string, string>;
+/**
+ * Extract the widget parameters from the current `window.location`.
+ * @returns The widget parameters.
+ */
+export declare function extractWidgetParameters(): WidgetParameters;
+/**
+ * Individual fields that are decoded inside a widget id.
+ */
+export type WidgetId = {
+    /**
+     * The widget id of the main widget if working with modals, or the widget id
+     * of the current widget if not.
+     */
+    mainWidgetId: string;
+    /**
+     * The room id the widget is registered in.
+     */
+    roomId?: string;
+    /**
+     * The user id of the user that registered the widget.
+     */
+    creator?: string;
+    /**
+     * True, if this widget is a modal widget.
+     */
+    isModal: boolean;
+};
+/**
+ * Parse a widget id into the individual fields.
+ * @param widgetId - The widget id to parse.
+ * @returns The individual fields encoded inside a widget id.
+ */
+export declare function parseWidgetId(widgetId: string): WidgetId;

package/build/cjs/api/parameters.test.d.cts

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

package/build/cjs/api/registration.d.cts

@@ -0,0 +1,33 @@
+import { WidgetApi, WidgetParameters, WidgetRegistration } from './types';
+/**
+ * Checks whether all widget parameters were provided to the widget.
+ *
+ * @param widgetApi - The widget api to read the parameters from
+ * @returns True, if all parameters were provided.
+ */
+export declare function hasRequiredWidgetParameters(widgetApi: WidgetApi): boolean;
+/**
+ * Generate a registration URL for the widget based on the current URL and
+ * include all widget parameters (and their placeholders).
+ * @param options - Options for generating the URL.
+ *                  Use `pathName` to include an optional sub path in the URL.
+ *                  Use `includeParameters` to append the widget parameters to
+ *                  the URL, defaults to `true`.
+ * @returns The generated URL.
+ */
+export declare function generateWidgetRegistrationUrl(options?: {
+    pathName?: string;
+    includeParameters?: boolean;
+    widgetParameters?: Partial<WidgetParameters>;
+}): string;
+export declare const STATE_EVENT_WIDGETS = "im.vector.modular.widgets";
+/**
+ * Repair/configure the registration of the current widget.
+ * This steps make sure to include all the required widget parameters in the
+ * URL. Support setting a widget name and additional parameters.
+ *
+ * @param widgetApi - The widget api of the current widget.
+ * @param registration - Optional configuration options for the widget
+ *                       registration, like the display name of the widget.
+ */
+export declare function repairWidgetRegistration(widgetApi: WidgetApi, registration?: WidgetRegistration): Promise<void>;

package/build/cjs/api/registration.test.d.cts

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