@workadventure/iframe-api-typings 1.5.0

package/Api/Events/ButtonClickedEvent.d.ts

@@ -0,0 +1,9 @@
+import * as tg from "generic-type-guard";
+export declare const isButtonClickedEvent: tg.TypeGuard<object & {
+    popupId: number;
+    buttonId: number;
+}>;
+/**
+ * A message sent from the game to the iFrame when a user enters or leaves a zone marked with the "zone" property.
+ */
+export declare type ButtonClickedEvent = tg.GuardedType<typeof isButtonClickedEvent>;

package/Api/Events/ChatEvent.d.ts

@@ -0,0 +1,9 @@
+import * as tg from "generic-type-guard";
+export declare const isChatEvent: tg.TypeGuard<object & {
+    message: string;
+    author: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type ChatEvent = tg.GuardedType<typeof isChatEvent>;

package/Api/Events/ClosePopupEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isClosePopupEvent: tg.TypeGuard<object & {
+    popupId: number;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type ClosePopupEvent = tg.GuardedType<typeof isClosePopupEvent>;

package/Api/Events/EmbeddedWebsiteEvent.d.ts

@@ -0,0 +1,39 @@
+import * as tg from "generic-type-guard";
+export declare const isRectangle: tg.TypeGuard<object & {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+export declare const isEmbeddedWebsiteEvent: tg.TypeGuard<object & {
+    name: string;
+} & Partial<{
+    url: string;
+    visible: boolean;
+    allowApi: boolean;
+    allow: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>>;
+export declare const isCreateEmbeddedWebsiteEvent: tg.TypeGuard<object & {
+    name: string;
+    url: string;
+    position: object & {
+        x: any;
+        y: any;
+        width: any;
+        height: any;
+    };
+} & Partial<{
+    visible: boolean;
+    allowApi: boolean;
+    allow: string;
+}>>;
+/**
+ * A message sent from the iFrame to the game to modify an embedded website
+ */
+export declare type ModifyEmbeddedWebsiteEvent = tg.GuardedType<typeof isEmbeddedWebsiteEvent>;
+export declare type CreateEmbeddedWebsiteEvent = tg.GuardedType<typeof isCreateEmbeddedWebsiteEvent>;
+export declare type Rectangle = tg.GuardedType<typeof isRectangle>;

package/Api/Events/EnterLeaveEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isEnterLeaveEvent: tg.TypeGuard<object & {
+    name: string;
+}>;
+/**
+ * A message sent from the game to the iFrame when a user enters or leaves a zone marked with the "zone" property.
+ */
+export declare type EnterLeaveEvent = tg.GuardedType<typeof isEnterLeaveEvent>;

package/Api/Events/GameStateEvent.d.ts

@@ -0,0 +1,14 @@
+import * as tg from "generic-type-guard";
+export declare const isGameStateEvent: tg.TypeGuard<object & {
+    roomId: string;
+    mapUrl: string;
+    nickname: string;
+    uuid: string | undefined;
+    startLayerName: string | null;
+    tags: string[];
+    variables: object;
+}>;
+/**
+ * A message sent from the game to the iFrame when the gameState is received by the script
+ */
+export declare type GameStateEvent = tg.GuardedType<typeof isGameStateEvent>;

package/Api/Events/GoToPageEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isGoToPageEvent: tg.TypeGuard<object & {
+    url: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type GoToPageEvent = tg.GuardedType<typeof isGoToPageEvent>;

package/Api/Events/HasPlayerMovedEvent.d.ts

@@ -0,0 +1,12 @@
+import * as tg from "generic-type-guard";
+export declare const isHasPlayerMovedEvent: tg.TypeGuard<object & {
+    direction: string;
+    moving: boolean;
+    x: number;
+    y: number;
+}>;
+/**
+ * A message sent from the game to the iFrame to notify a movement from the current player.
+ */
+export declare type HasPlayerMovedEvent = tg.GuardedType<typeof isHasPlayerMovedEvent>;
+export declare type HasPlayerMovedEventCallback = (event: HasPlayerMovedEvent) => void;

package/Api/Events/IframeEvent.d.ts

@@ -0,0 +1,207 @@
+import * as tg from "generic-type-guard";
+import type { ButtonClickedEvent } from "./ButtonClickedEvent";
+import type { ChatEvent } from "./ChatEvent";
+import type { ClosePopupEvent } from "./ClosePopupEvent";
+import type { EnterLeaveEvent } from "./EnterLeaveEvent";
+import type { GoToPageEvent } from "./GoToPageEvent";
+import type { LoadPageEvent } from "./LoadPageEvent";
+import type { OpenCoWebSiteEvent } from "./OpenCoWebSiteEvent";
+import type { OpenPopupEvent } from "./OpenPopupEvent";
+import type { OpenTabEvent } from "./OpenTabEvent";
+import type { UserInputChatEvent } from "./UserInputChatEvent";
+import type { LayerEvent } from "./LayerEvent";
+import type { SetPropertyEvent } from "./setPropertyEvent";
+import type { LoadSoundEvent } from "./LoadSoundEvent";
+import type { PlaySoundEvent } from "./PlaySoundEvent";
+import type { MenuItemClickedEvent } from "./ui/MenuItemClickedEvent";
+import type { HasPlayerMovedEvent } from "./HasPlayerMovedEvent";
+import type { SetTilesEvent } from "./SetTilesEvent";
+import type { SetVariableEvent } from "./SetVariableEvent";
+import type { EmbeddedWebsite } from "../iframe/Room/EmbeddedWebsite";
+import type { LoadTilesetEvent } from "./LoadTilesetEvent";
+import type { MessageReferenceEvent } from "./ui/TriggerActionMessageEvent";
+import type { MenuRegisterEvent, UnregisterMenuEvent } from "./ui/MenuRegisterEvent";
+export interface TypedMessageEvent<T> extends MessageEvent {
+    data: T;
+}
+/**
+ * List event types sent from an iFrame to WorkAdventure
+ */
+export declare type IframeEventMap = {
+    loadPage: LoadPageEvent;
+    chat: ChatEvent;
+    openPopup: OpenPopupEvent;
+    closePopup: ClosePopupEvent;
+    openTab: OpenTabEvent;
+    goToPage: GoToPageEvent;
+    openCoWebSite: OpenCoWebSiteEvent;
+    closeCoWebSite: null;
+    disablePlayerControls: null;
+    restorePlayerControls: null;
+    displayBubble: null;
+    removeBubble: null;
+    onPlayerMove: undefined;
+    showLayer: LayerEvent;
+    hideLayer: LayerEvent;
+    setProperty: SetPropertyEvent;
+    loadSound: LoadSoundEvent;
+    playSound: PlaySoundEvent;
+    stopSound: null;
+    getState: undefined;
+    loadTileset: LoadTilesetEvent;
+    registerMenu: MenuRegisterEvent;
+    unregisterMenu: UnregisterMenuEvent;
+    setTiles: SetTilesEvent;
+    modifyEmbeddedWebsite: Partial<EmbeddedWebsite>;
+};
+export interface IframeEvent<T extends keyof IframeEventMap> {
+    type: T;
+    data: IframeEventMap[T];
+}
+export declare const isIframeEventWrapper: (event: any) => event is IframeEvent<keyof IframeEventMap>;
+export interface IframeResponseEventMap {
+    userInputChat: UserInputChatEvent;
+    enterEvent: EnterLeaveEvent;
+    leaveEvent: EnterLeaveEvent;
+    buttonClickedEvent: ButtonClickedEvent;
+    hasPlayerMoved: HasPlayerMovedEvent;
+    menuItemClicked: MenuItemClickedEvent;
+    setVariable: SetVariableEvent;
+    messageTriggered: MessageReferenceEvent;
+}
+export interface IframeResponseEvent<T extends keyof IframeResponseEventMap> {
+    type: T;
+    data: IframeResponseEventMap[T];
+}
+export declare const isIframeResponseEventWrapper: (event: {
+    type?: string;
+}) => event is IframeResponseEvent<keyof IframeResponseEventMap>;
+/**
+ * List event types sent from an iFrame to WorkAdventure that expect a unique answer from WorkAdventure along the type for the answer from WorkAdventure to the iFrame.
+ * Types are defined using Type guards that will actually bused to enforce and check types.
+ */
+export declare const iframeQueryMapTypeGuards: {
+    getState: {
+        query: tg.TypeGuard<undefined>;
+        answer: tg.TypeGuard<object & {
+            roomId: string;
+            mapUrl: string;
+            nickname: string;
+            uuid: string | undefined;
+            startLayerName: string | null;
+            tags: string[];
+            variables: object;
+        }>;
+    };
+    getMapData: {
+        query: tg.TypeGuard<undefined>;
+        answer: tg.TypeGuard<object & {
+            data: object;
+        }>;
+    };
+    setVariable: {
+        query: tg.TypeGuard<object & {
+            key: string;
+            value: unknown;
+        }>;
+        answer: tg.TypeGuard<undefined>;
+    };
+    loadTileset: {
+        query: tg.TypeGuard<object & {
+            url: string;
+        }>;
+        answer: tg.TypeGuard<number>;
+    };
+    triggerActionMessage: {
+        query: tg.TypeGuard<object & {
+            message: string;
+            uuid: string;
+            type: "message" | "warning";
+        }>;
+        answer: tg.TypeGuard<undefined>;
+    };
+    removeActionMessage: {
+        query: tg.TypeGuard<object & {
+            uuid: string;
+        }>;
+        answer: tg.TypeGuard<undefined>;
+    };
+    getEmbeddedWebsite: {
+        query: tg.TypeGuard<string>;
+        answer: tg.TypeGuard<object & {
+            name: string;
+            url: string;
+            position: object & {
+                x: any;
+                y: any;
+                width: any;
+                height: any;
+            };
+        } & Partial<{
+            visible: boolean;
+            allowApi: boolean;
+            allow: string;
+        }>>;
+    };
+    deleteEmbeddedWebsite: {
+        query: tg.TypeGuard<string>;
+        answer: tg.TypeGuard<undefined>;
+    };
+    createEmbeddedWebsite: {
+        query: tg.TypeGuard<object & {
+            name: string;
+            url: string;
+            position: object & {
+                x: any;
+                y: any;
+                width: any;
+                height: any;
+            };
+        } & Partial<{
+            visible: boolean;
+            allowApi: boolean;
+            allow: string;
+        }>>;
+        answer: tg.TypeGuard<undefined>;
+    };
+};
+declare type GuardedType<T> = T extends (x: unknown) => x is infer T ? T : never;
+declare type IframeQueryMapTypeGuardsType = typeof iframeQueryMapTypeGuards;
+declare type UnknownToVoid<T> = undefined extends T ? void : T;
+export declare type IframeQueryMap = {
+    [key in keyof IframeQueryMapTypeGuardsType]: {
+        query: GuardedType<IframeQueryMapTypeGuardsType[key]["query"]>;
+        answer: UnknownToVoid<GuardedType<IframeQueryMapTypeGuardsType[key]["answer"]>>;
+    };
+};
+export interface IframeQuery<T extends keyof IframeQueryMap> {
+    type: T;
+    data: IframeQueryMap[T]["query"];
+}
+export interface IframeQueryWrapper<T extends keyof IframeQueryMap> {
+    id: number;
+    query: IframeQuery<T>;
+}
+export declare const isIframeQueryKey: (type: string) => type is "getState" | "getMapData" | "setVariable" | "loadTileset" | "triggerActionMessage" | "removeActionMessage" | "getEmbeddedWebsite" | "deleteEmbeddedWebsite" | "createEmbeddedWebsite";
+export declare const isIframeQuery: (event: any) => event is IframeQuery<"getState" | "getMapData" | "setVariable" | "loadTileset" | "triggerActionMessage" | "removeActionMessage" | "getEmbeddedWebsite" | "deleteEmbeddedWebsite" | "createEmbeddedWebsite">;
+export declare const isIframeQueryWrapper: (event: any) => event is IframeQueryWrapper<"getState" | "getMapData" | "setVariable" | "loadTileset" | "triggerActionMessage" | "removeActionMessage" | "getEmbeddedWebsite" | "deleteEmbeddedWebsite" | "createEmbeddedWebsite">;
+export interface IframeAnswerEvent<T extends keyof IframeQueryMap> {
+    id: number;
+    type: T;
+    data: IframeQueryMap[T]["answer"];
+}
+export declare const isIframeAnswerEvent: (event: {
+    type?: string;
+    id?: number;
+}) => event is IframeAnswerEvent<"getState" | "getMapData" | "setVariable" | "loadTileset" | "triggerActionMessage" | "removeActionMessage" | "getEmbeddedWebsite" | "deleteEmbeddedWebsite" | "createEmbeddedWebsite">;
+export interface IframeErrorAnswerEvent {
+    id: number;
+    type: keyof IframeQueryMap;
+    error: string;
+}
+export declare const isIframeErrorAnswerEvent: (event: {
+    type?: string;
+    id?: number;
+    error?: string;
+}) => event is IframeErrorAnswerEvent;
+export {};

package/Api/Events/LayerEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isLayerEvent: tg.TypeGuard<object & {
+    name: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to show/hide a layer.
+ */
+export declare type LayerEvent = tg.GuardedType<typeof isLayerEvent>;

package/Api/Events/LoadPageEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isLoadPageEvent: tg.TypeGuard<object & {
+    url: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type LoadPageEvent = tg.GuardedType<typeof isLoadPageEvent>;

package/Api/Events/LoadSoundEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isLoadSoundEvent: tg.TypeGuard<object & {
+    url: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type LoadSoundEvent = tg.GuardedType<typeof isLoadSoundEvent>;

package/Api/Events/LoadTilesetEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isLoadTilesetEvent: tg.TypeGuard<object & {
+    url: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type LoadTilesetEvent = tg.GuardedType<typeof isLoadTilesetEvent>;

package/Api/Events/MapDataEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isMapDataEvent: tg.TypeGuard<object & {
+    data: object;
+}>;
+/**
+ * A message sent from the game to the iFrame when the data of the layers change after the iFrame send a message to the game that it want to listen to the data of the layers
+ */
+export declare type MapDataEvent = tg.GuardedType<typeof isMapDataEvent>;

package/Api/Events/OpenCoWebSiteEvent.d.ts

@@ -0,0 +1,10 @@
+import * as tg from "generic-type-guard";
+export declare const isOpenCoWebsite: tg.TypeGuard<object & {
+    url: string;
+    allowApi: boolean;
+    allowPolicy: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type OpenCoWebSiteEvent = tg.GuardedType<typeof isOpenCoWebsite>;

package/Api/Events/OpenPopupEvent.d.ts

@@ -0,0 +1,14 @@
+import * as tg from "generic-type-guard";
+export declare const isOpenPopupEvent: tg.TypeGuard<object & {
+    popupId: number;
+    targetObject: string;
+    message: string;
+    buttons: (object & {
+        label: any;
+        className: any;
+    })[];
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type OpenPopupEvent = tg.GuardedType<typeof isOpenPopupEvent>;

package/Api/Events/OpenTabEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isOpenTabEvent: tg.TypeGuard<object & {
+    url: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type OpenTabEvent = tg.GuardedType<typeof isOpenTabEvent>;

package/Api/Events/PlaySoundEvent.d.ts

@@ -0,0 +1,17 @@
+import * as tg from "generic-type-guard";
+export declare const isPlaySoundEvent: tg.TypeGuard<object & {
+    url: string;
+    config: (object & {
+        volume: any;
+        loop: any;
+        mute: any;
+        rate: any;
+        detune: any;
+        seek: any;
+        delay: any;
+    }) | undefined;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type PlaySoundEvent = tg.GuardedType<typeof isPlaySoundEvent>;

package/Api/Events/SetTilesEvent.d.ts

@@ -0,0 +1,11 @@
+import * as tg from "generic-type-guard";
+export declare const isSetTilesEvent: tg.TypeGuard<(object & {
+    x: number;
+    y: number;
+    tile: string | number | null;
+    layer: string;
+})[]>;
+/**
+ * A message sent from the iFrame to the game to set one or many tiles.
+ */
+export declare type SetTilesEvent = tg.GuardedType<typeof isSetTilesEvent>;

package/Api/Events/SetVariableEvent.d.ts

@@ -0,0 +1,16 @@
+import * as tg from "generic-type-guard";
+export declare const isSetVariableEvent: tg.TypeGuard<object & {
+    key: string;
+    value: unknown;
+}>;
+/**
+ * A message sent from the iFrame to the game to change the value of the property of the layer
+ */
+export declare type SetVariableEvent = tg.GuardedType<typeof isSetVariableEvent>;
+export declare const isSetVariableIframeEvent: tg.TypeGuard<object & {
+    type: "setVariable";
+    data: object & {
+        key: any;
+        value: any;
+    };
+}>;

package/Api/Events/StopSoundEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isStopSoundEvent: tg.TypeGuard<object & {
+    url: string;
+}>;
+/**
+ * A message sent from the iFrame to the game to add a message in the chat.
+ */
+export declare type StopSoundEvent = tg.GuardedType<typeof isStopSoundEvent>;

package/Api/Events/UserInputChatEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isUserInputChatEvent: tg.TypeGuard<object & {
+    message: string;
+}>;
+/**
+ * A message sent from the game to the iFrame when a user types a message in the chat.
+ */
+export declare type UserInputChatEvent = tg.GuardedType<typeof isUserInputChatEvent>;

package/Api/Events/setPropertyEvent.d.ts

@@ -0,0 +1,10 @@
+import * as tg from "generic-type-guard";
+export declare const isSetPropertyEvent: tg.TypeGuard<object & {
+    layerName: string;
+    propertyName: string;
+    propertyValue: string | number | boolean | undefined;
+}>;
+/**
+ * A message sent from the iFrame to the game to change the value of the property of the layer
+ */
+export declare type SetPropertyEvent = tg.GuardedType<typeof isSetPropertyEvent>;

package/Api/Events/ui/MenuItemClickedEvent.d.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+export declare const isMenuItemClickedEvent: tg.TypeGuard<object & {
+    menuItem: string;
+}>;
+/**
+ * A message sent from the game to the iFrame when a menu item is clicked.
+ */
+export declare type MenuItemClickedEvent = tg.GuardedType<typeof isMenuItemClickedEvent>;

package/Api/Events/ui/MenuRegisterEvent.d.ts

@@ -0,0 +1,22 @@
+import * as tg from "generic-type-guard";
+/**
+ * A message sent from a script to the game to remove a custom menu from the menu
+ */
+export declare const isUnregisterMenuEvent: tg.TypeGuard<object & {
+    name: string;
+}>;
+export declare type UnregisterMenuEvent = tg.GuardedType<typeof isUnregisterMenuEvent>;
+export declare const isMenuRegisterOptions: tg.TypeGuard<object & {
+    allowApi: boolean;
+}>;
+/**
+ * A message sent from a script to the game to add a custom menu from the menu
+ */
+export declare const isMenuRegisterEvent: tg.TypeGuard<object & {
+    name: string;
+    iframe: string | undefined;
+    options: object & {
+        allowApi: any;
+    };
+}>;
+export declare type MenuRegisterEvent = tg.GuardedType<typeof isMenuRegisterEvent>;

package/Api/Events/ui/TriggerActionMessageEvent.d.ts

@@ -0,0 +1,15 @@
+import * as tg from "generic-type-guard";
+export declare const triggerActionMessage = "triggerActionMessage";
+export declare const removeActionMessage = "removeActionMessage";
+export declare const isActionMessageType: tg.TypeGuard<"message" | "warning">;
+export declare type ActionMessageType = tg.GuardedType<typeof isActionMessageType>;
+export declare const isTriggerActionMessageEvent: tg.TypeGuard<object & {
+    message: string;
+    uuid: string;
+    type: "message" | "warning";
+}>;
+export declare type TriggerActionMessageEvent = tg.GuardedType<typeof isTriggerActionMessageEvent>;
+export declare const isMessageReferenceEvent: tg.TypeGuard<object & {
+    uuid: string;
+}>;
+export declare type MessageReferenceEvent = tg.GuardedType<typeof isMessageReferenceEvent>;

package/Api/Events/ui/TriggerMessageEventHandler.d.ts

@@ -0,0 +1,14 @@
+import * as tg from "generic-type-guard";
+export declare const isTriggerMessageHandlerEvent: tg.PartialTypeGuard<unknown, (object & {
+    type: "triggerActionMessage";
+    data: object & {
+        message: any;
+        uuid: any;
+        type: any;
+    };
+}) | (object & {
+    type: "removeActionMessage";
+    data: object & {
+        uuid: any;
+    };
+})>;

package/Api/IframeListener.d.ts

@@ -0,0 +1,138 @@
+import { IframeQueryMap, IframeResponseEvent, IframeResponseEventMap } from "./Events/IframeEvent";
+import type { HasPlayerMovedEvent } from "./Events/HasPlayerMovedEvent";
+import type { SetVariableEvent } from "./Events/SetVariableEvent";
+declare type AnswererCallback<T extends keyof IframeQueryMap> = (query: IframeQueryMap[T]["query"], source: MessageEventSource | null) => IframeQueryMap[T]["answer"] | PromiseLike<IframeQueryMap[T]["answer"]>;
+/**
+ * Listens to messages from iframes and turn those messages into easy to use observables.
+ * Also allows to send messages to those iframes.
+ */
+declare class IframeListener {
+    private readonly _openPopupStream;
+    readonly openPopupStream: import("rxjs").Observable<object & {
+        popupId: number;
+        targetObject: string;
+        message: string;
+        buttons: (object & {
+            label: any;
+            className: any;
+        })[];
+    }>;
+    private readonly _openTabStream;
+    readonly openTabStream: import("rxjs").Observable<object & {
+        url: string;
+    }>;
+    private readonly _loadPageStream;
+    readonly loadPageStream: import("rxjs").Observable<string>;
+    private readonly _openCoWebSiteStream;
+    readonly openCoWebSiteStream: import("rxjs").Observable<object & {
+        url: string;
+        allowApi: boolean;
+        allowPolicy: string;
+    }>;
+    private readonly _disablePlayerControlStream;
+    readonly disablePlayerControlStream: import("rxjs").Observable<void>;
+    private readonly _enablePlayerControlStream;
+    readonly enablePlayerControlStream: import("rxjs").Observable<void>;
+    private readonly _closePopupStream;
+    readonly closePopupStream: import("rxjs").Observable<object & {
+        popupId: number;
+    }>;
+    private readonly _displayBubbleStream;
+    readonly displayBubbleStream: import("rxjs").Observable<void>;
+    private readonly _removeBubbleStream;
+    readonly removeBubbleStream: import("rxjs").Observable<void>;
+    private readonly _showLayerStream;
+    readonly showLayerStream: import("rxjs").Observable<object & {
+        name: string;
+    }>;
+    private readonly _hideLayerStream;
+    readonly hideLayerStream: import("rxjs").Observable<object & {
+        name: string;
+    }>;
+    private readonly _setPropertyStream;
+    readonly setPropertyStream: import("rxjs").Observable<object & {
+        layerName: string;
+        propertyName: string;
+        propertyValue: string | number | boolean | undefined;
+    }>;
+    private readonly _playSoundStream;
+    readonly playSoundStream: import("rxjs").Observable<object & {
+        url: string;
+        config: (object & {
+            volume: any;
+            loop: any;
+            mute: any;
+            rate: any;
+            detune: any;
+            seek: any;
+            delay: any;
+        }) | undefined;
+    }>;
+    private readonly _stopSoundStream;
+    readonly stopSoundStream: import("rxjs").Observable<object & {
+        url: string;
+    }>;
+    private readonly _loadSoundStream;
+    readonly loadSoundStream: import("rxjs").Observable<object & {
+        url: string;
+    }>;
+    private readonly _setTilesStream;
+    readonly setTilesStream: import("rxjs").Observable<(object & {
+        x: number;
+        y: number;
+        tile: string | number | null;
+        layer: string;
+    })[]>;
+    private readonly _modifyEmbeddedWebsiteStream;
+    readonly modifyEmbeddedWebsiteStream: import("rxjs").Observable<object & {
+        name: string;
+    } & Partial<{
+        url: string;
+        visible: boolean;
+        allowApi: boolean;
+        allow: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>>;
+    private readonly iframes;
+    private readonly iframeCloseCallbacks;
+    private readonly scripts;
+    private sendPlayerMove;
+    private answerers;
+    init(): void;
+    /**
+     * Allows the passed iFrame to send/receive messages via the API.
+     */
+    registerIframe(iframe: HTMLIFrameElement): void;
+    unregisterIframe(iframe: HTMLIFrameElement): void;
+    registerScript(scriptUrl: string): Promise<void>;
+    private getBaseUrl;
+    private static getIFrameId;
+    unregisterScript(scriptUrl: string): void;
+    sendUserInputChat(message: string): void;
+    sendEnterEvent(name: string): void;
+    sendLeaveEvent(name: string): void;
+    hasPlayerMoved(event: HasPlayerMovedEvent): void;
+    sendButtonClickedEvent(popupId: number, buttonId: number): void;
+    setVariable(setVariableEvent: SetVariableEvent): void;
+    sendActionMessageTriggered(uuid: string): void;
+    /**
+     * Sends the message... to all allowed iframes.
+     */
+    postMessage(message: IframeResponseEvent<keyof IframeResponseEventMap>): void;
+    /**
+     * Registers a callback that can be used to respond to some query (as defined in the IframeQueryMap type).
+     *
+     * Important! There can be only one "answerer" so registering a new one will unregister the old one.
+     *
+     * @param key The "type" of the query we are answering
+     * @param callback
+     */
+    registerAnswerer<T extends keyof IframeQueryMap>(key: T, callback: AnswererCallback<T>): void;
+    unregisterAnswerer(key: keyof IframeQueryMap): void;
+    dispatchVariableToOtherIframes(key: string, value: unknown, source: MessageEventSource | null): void;
+}
+export declare const iframeListener: IframeListener;
+export {};

package/Api/ScriptUtils.d.ts

@@ -0,0 +1,10 @@
+import type { ChatEvent } from "./Events/ChatEvent";
+declare class ScriptUtils {
+    openTab(url: string): void;
+    goToPage(url: string): void;
+    openCoWebsite(url: string, base: string, api: boolean, policy: string): void;
+    closeCoWebSite(): void;
+    sendAnonymousChat(chatEvent: ChatEvent): void;
+}
+export declare const scriptUtils: ScriptUtils;
+export {};

package/Api/iframe/IframeApiContribution.d.ts

@@ -0,0 +1,25 @@
+import type * as tg from "generic-type-guard";
+import type { IframeEvent, IframeEventMap, IframeQuery, IframeQueryMap, IframeResponseEventMap } from "../Events/IframeEvent";
+export declare function sendToWorkadventure(content: IframeEvent<keyof IframeEventMap>): void;
+export declare const answerPromises: Map<number, {
+    resolve: (value: IframeQueryMap[keyof IframeQueryMap]["answer"] | PromiseLike<IframeQueryMap[keyof IframeQueryMap]["answer"]>) => void;
+    reject: (reason?: any) => void;
+}>;
+export declare function queryWorkadventure<T extends keyof IframeQueryMap>(content: IframeQuery<T>): Promise<IframeQueryMap[T]["answer"]>;
+export interface IframeCallback<Key extends keyof IframeResponseEventMap, T = IframeResponseEventMap[Key], Guard = tg.TypeGuard<T>> {
+    typeChecker: Guard;
+    callback: (payloadData: T) => void;
+}
+export interface IframeCallbackContribution<Key extends keyof IframeResponseEventMap> extends IframeCallback<Key> {
+    type: Key;
+}
+/**
+ * !! be aware that the implemented attributes (addMethodsAtRoot and subObjectIdentifier) must be readonly
+ *
+ *
+ */
+export declare abstract class IframeApiContribution<T extends {
+    callbacks: Array<IframeCallbackContribution<keyof IframeResponseEventMap>>;
+}> {
+    abstract callbacks: T["callbacks"];
+}

package/Api/iframe/Room/EmbeddedWebsite.d.ts

@@ -0,0 +1,17 @@
+import type { CreateEmbeddedWebsiteEvent } from "../../Events/EmbeddedWebsiteEvent";
+export declare class EmbeddedWebsite {
+    private config;
+    readonly name: string;
+    private _url;
+    private _visible;
+    private _allow;
+    private _allowApi;
+    private _position;
+    constructor(config: CreateEmbeddedWebsiteEvent);
+    set url(url: string);
+    set visible(visible: boolean);
+    set x(x: number);
+    set y(y: number);
+    set width(width: number);
+    set height(height: number);
+}

package/Api/iframe/Sound/Sound.d.ts

@@ -0,0 +1,7 @@
+import SoundConfig = Phaser.Types.Sound.SoundConfig;
+export declare class Sound {
+    private url;
+    constructor(url: string);
+    play(config: SoundConfig | undefined): string;
+    stop(): string;
+}

package/Api/iframe/Ui/ActionMessage.d.ts

@@ -0,0 +1,12 @@
+import type { ActionMessageOptions } from "../ui";
+export declare class ActionMessage {
+    private onRemove;
+    readonly uuid: string;
+    private readonly type;
+    private readonly message;
+    private readonly callback;
+    constructor(actionMessageOptions: ActionMessageOptions, onRemove: () => void);
+    private create;
+    remove(): Promise<void>;
+    triggerCallback(): void;
+}

package/Api/iframe/Ui/ButtonDescriptor.d.ts

@@ -0,0 +1,16 @@
+import type { Popup } from "./Popup";
+export declare type ButtonClickedCallback = (popup: Popup) => void;
+export interface ButtonDescriptor {
+    /**
+     * The label of the button
+     */
+    label: string;
+    /**
+     * The type of the button. Can be one of "normal", "primary", "success", "warning", "error", "disabled"
+     */
+    className?: "normal" | "primary" | "success" | "warning" | "error" | "disabled";
+    /**
+     * Callback called if the button is pressed
+     */
+    callback: ButtonClickedCallback;
+}

package/Api/iframe/Ui/Menu.d.ts

@@ -0,0 +1,8 @@
+export declare class Menu {
+    private menuName;
+    constructor(menuName: string);
+    /**
+     * remove the menu
+     */
+    remove(): void;
+}

package/Api/iframe/Ui/MenuItem.d.ts

@@ -0,0 +1 @@
+export declare function sendMenuClickedEvent(menuItem: string): void;

package/Api/iframe/Ui/Popup.d.ts

@@ -0,0 +1,8 @@
+export declare class Popup {
+    private id;
+    constructor(id: number);
+    /**
+     * Closes the popup
+     */
+    close(): void;
+}

package/Api/iframe/chat.d.ts

@@ -0,0 +1,11 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+export declare class WorkadventureChatCommands extends IframeApiContribution<WorkadventureChatCommands> {
+    callbacks: import("./IframeApiContribution").IframeCallbackContribution<keyof import("../Events/IframeEvent").IframeResponseEventMap>[];
+    sendChatMessage(message: string, author: string): void;
+    /**
+     * Listen to messages sent by the local user, in the chat.
+     */
+    onChatMessage(callback: (message: string) => void): void;
+}
+declare const _default: WorkadventureChatCommands;
+export default _default;

package/Api/iframe/controls.d.ts

@@ -0,0 +1,8 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+export declare class WorkadventureControlsCommands extends IframeApiContribution<WorkadventureControlsCommands> {
+    callbacks: never[];
+    disablePlayerControls(): void;
+    restorePlayerControls(): void;
+}
+declare const _default: WorkadventureControlsCommands;
+export default _default;

package/Api/iframe/nav.d.ts

@@ -0,0 +1,11 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+export declare class WorkadventureNavigationCommands extends IframeApiContribution<WorkadventureNavigationCommands> {
+    callbacks: never[];
+    openTab(url: string): void;
+    goToPage(url: string): void;
+    goToRoom(url: string): void;
+    openCoWebSite(url: string, allowApi?: boolean, allowPolicy?: string): void;
+    closeCoWebSite(): void;
+}
+declare const _default: WorkadventureNavigationCommands;
+export default _default;

package/Api/iframe/player.d.ts

@@ -0,0 +1,14 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import type { HasPlayerMovedEventCallback } from "../Events/HasPlayerMovedEvent";
+export declare const setPlayerName: (name: string) => void;
+export declare const setTags: (_tags: string[]) => void;
+export declare const setUuid: (_uuid: string | undefined) => void;
+export declare class WorkadventurePlayerCommands extends IframeApiContribution<WorkadventurePlayerCommands> {
+    callbacks: import("./IframeApiContribution").IframeCallbackContribution<keyof import("../Events/IframeEvent").IframeResponseEventMap>[];
+    onPlayerMove(callback: HasPlayerMovedEventCallback): void;
+    get name(): string;
+    get tags(): string[];
+    get id(): string | undefined;
+}
+declare const _default: WorkadventurePlayerCommands;
+export default _default;

package/Api/iframe/registeredCallbacks.d.ts

@@ -0,0 +1,7 @@
+import type { IframeResponseEventMap } from "../../Api/Events/IframeEvent";
+import type { IframeCallback } from "../../Api/iframe/IframeApiContribution";
+import type { IframeCallbackContribution } from "../../Api/iframe/IframeApiContribution";
+export declare const registeredCallbacks: {
+    [K in keyof IframeResponseEventMap]?: IframeCallback<K>;
+};
+export declare function apiCallback<T extends keyof IframeResponseEventMap>(callbackData: IframeCallbackContribution<T>): IframeCallbackContribution<keyof IframeResponseEventMap>;

package/Api/iframe/room.d.ts

@@ -0,0 +1,27 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import type { ITiledMap } from "../../Phaser/Map/ITiledMap";
+import type { WorkadventureRoomWebsiteCommands } from "./website";
+interface TileDescriptor {
+    x: number;
+    y: number;
+    tile: number | string | null;
+    layer: string;
+}
+export declare const setRoomId: (id: string) => void;
+export declare const setMapURL: (url: string) => void;
+export declare class WorkadventureRoomCommands extends IframeApiContribution<WorkadventureRoomCommands> {
+    callbacks: import("./IframeApiContribution").IframeCallbackContribution<keyof import("../Events/IframeEvent").IframeResponseEventMap>[];
+    onEnterZone(name: string, callback: () => void): void;
+    onLeaveZone(name: string, callback: () => void): void;
+    showLayer(layerName: string): void;
+    hideLayer(layerName: string): void;
+    setProperty(layerName: string, propertyName: string, propertyValue: string | number | boolean | undefined): void;
+    getTiledMap(): Promise<ITiledMap>;
+    setTiles(tiles: TileDescriptor[]): void;
+    get id(): string;
+    get mapURL(): string;
+    loadTileset(url: string): Promise<number>;
+    get website(): WorkadventureRoomWebsiteCommands;
+}
+declare const _default: WorkadventureRoomCommands;
+export default _default;

package/Api/iframe/sound.d.ts

@@ -0,0 +1,8 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import { Sound } from "./Sound/Sound";
+export declare class WorkadventureSoundCommands extends IframeApiContribution<WorkadventureSoundCommands> {
+    callbacks: never[];
+    loadSound(url: string): Sound;
+}
+declare const _default: WorkadventureSoundCommands;
+export default _default;

package/Api/iframe/state.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from "rxjs";
+import { IframeApiContribution } from "./IframeApiContribution";
+export declare const initVariables: (_variables: Map<string, unknown>) => void;
+export declare class WorkadventureStateCommands extends IframeApiContribution<WorkadventureStateCommands> {
+    callbacks: import("./IframeApiContribution").IframeCallbackContribution<keyof import("../Events/IframeEvent").IframeResponseEventMap>[];
+    saveVariable(key: string, value: unknown): Promise<void>;
+    loadVariable(key: string): unknown;
+    hasVariable(key: string): boolean;
+    onVariableChange(key: string): Observable<unknown>;
+}
+declare const proxyCommand: WorkadventureStateCommands & {
+    [key: string]: unknown;
+};
+export default proxyCommand;

package/Api/iframe/ui.d.ts

@@ -0,0 +1,27 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import type { ButtonDescriptor } from "./Ui/ButtonDescriptor";
+import { Popup } from "./Ui/Popup";
+import { ActionMessage } from "./Ui/ActionMessage";
+import { Menu } from "./Ui/Menu";
+import type { RequireOnlyOne } from "../types";
+interface MenuDescriptor {
+    callback?: (commandDescriptor: string) => void;
+    iframe?: string;
+    allowApi?: boolean;
+}
+export declare type MenuOptions = RequireOnlyOne<MenuDescriptor, "callback" | "iframe">;
+export interface ActionMessageOptions {
+    message: string;
+    type?: "message" | "warning";
+    callback: () => void;
+}
+export declare class WorkAdventureUiCommands extends IframeApiContribution<WorkAdventureUiCommands> {
+    callbacks: import("./IframeApiContribution").IframeCallbackContribution<keyof import("../Events/IframeEvent").IframeResponseEventMap>[];
+    openPopup(targetObject: string, message: string, buttons: ButtonDescriptor[]): Popup;
+    registerMenuCommand(commandDescriptor: string, options: MenuOptions | ((commandDescriptor: string) => void)): Menu;
+    displayBubble(): void;
+    removeBubble(): void;
+    displayActionMessage(actionMessageOptions: ActionMessageOptions): ActionMessage;
+}
+declare const _default: WorkAdventureUiCommands;
+export default _default;

package/Api/iframe/website.d.ts

@@ -0,0 +1,11 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import { EmbeddedWebsite } from "./Room/EmbeddedWebsite";
+import type { CreateEmbeddedWebsiteEvent } from "../Events/EmbeddedWebsiteEvent";
+export declare class WorkadventureRoomWebsiteCommands extends IframeApiContribution<WorkadventureRoomWebsiteCommands> {
+    callbacks: never[];
+    get(objectName: string): Promise<EmbeddedWebsite>;
+    create(createEmbeddedWebsiteEvent: CreateEmbeddedWebsiteEvent): EmbeddedWebsite;
+    delete(objectName: string): Promise<void>;
+}
+declare const _default: WorkadventureRoomWebsiteCommands;
+export default _default;

package/Api/types.d.ts

@@ -0,0 +1,3 @@
+export declare type RequireOnlyOne<T, keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, keys>> & {
+    [K in keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<keys, K>, undefined>>;
+}[keys];

package/README.md

@@ -0,0 +1,27 @@
+<h1 align="center">WorkAdventure - IFrame API typings for Typescript</h1>
+
+<p align="center">This package contains Typescript typings for <a href="https://workadventu.re/map-building/scripting">WorkAdventure's map scripting API</a></p>
+
+<hr/>
+
+[WorkAdventure](https://workadventu.re) comes with a scripting API. Using this API, you can add some intelligence to your map.
+You use this API by loading an external script directly from WorkAdventure (at https://play.workadventu.re/iframe_api.js), or this script is loaded
+for you if you are using the "script" property of a map.
+
+This project contains Typescript typings for the `WA` object provided by this script.
+
+## Usage
+
+This package is only useful if you are using Typescript to script your WorkAdventure maps.
+
+## Download & Installation
+
+```shell
+$ npm install @workadventure/iframe-api-typings
+```
+
+or
+
+```shell
+$ yarn add @workadventure/iframe-api-typings
+```

package/iframe_api.d.ts

@@ -0,0 +1,84 @@
+import type { ButtonDescriptor } from "./Api/iframe/Ui/ButtonDescriptor";
+import type { Popup } from "./Api/iframe/Ui/Popup";
+import type { Sound } from "./Api/iframe/Sound/Sound";
+declare const wa: {
+    ui: import("./Api/iframe/ui").WorkAdventureUiCommands;
+    nav: import("./Api/iframe/nav").WorkadventureNavigationCommands;
+    controls: import("./Api/iframe/controls").WorkadventureControlsCommands;
+    chat: import("./Api/iframe/chat").WorkadventureChatCommands;
+    sound: import("./Api/iframe/sound").WorkadventureSoundCommands;
+    room: import("./Api/iframe/room").WorkadventureRoomCommands;
+    player: import("./Api/iframe/player").WorkadventurePlayerCommands;
+    state: import("./Api/iframe/state").WorkadventureStateCommands & {
+        [key: string]: unknown;
+    };
+    onInit(): Promise<void>;
+    /**
+     * @deprecated Use WA.chat.sendChatMessage instead
+     */
+    sendChatMessage(message: string, author: string): void;
+    /**
+     * @deprecated Use WA.chat.disablePlayerControls instead
+     */
+    disablePlayerControls(): void;
+    /**
+     * @deprecated Use WA.controls.restorePlayerControls instead
+     */
+    restorePlayerControls(): void;
+    /**
+     * @deprecated Use WA.ui.displayBubble instead
+     */
+    displayBubble(): void;
+    /**
+     * @deprecated Use WA.ui.removeBubble instead
+     */
+    removeBubble(): void;
+    /**
+     * @deprecated Use WA.nav.openTab instead
+     */
+    openTab(url: string): void;
+    /**
+     * @deprecated Use WA.sound.loadSound instead
+     */
+    loadSound(url: string): Sound;
+    /**
+     * @deprecated Use WA.nav.goToPage instead
+     */
+    goToPage(url: string): void;
+    /**
+     * @deprecated Use WA.nav.goToRoom instead
+     */
+    goToRoom(url: string): void;
+    /**
+     * @deprecated Use WA.nav.openCoWebSite instead
+     */
+    openCoWebSite(url: string, allowApi?: boolean, allowPolicy?: string): void;
+    /**
+     * @deprecated Use WA.nav.closeCoWebSite instead
+     */
+    closeCoWebSite(): void;
+    /**
+     * @deprecated Use WA.ui.openPopup instead
+     */
+    openPopup(targetObject: string, message: string, buttons: ButtonDescriptor[]): Popup;
+    /**
+     * @deprecated Use WA.chat.onChatMessage instead
+     */
+    onChatMessage(callback: (message: string) => void): void;
+    /**
+     * @deprecated Use WA.room.onEnterZone instead
+     */
+    onEnterZone(name: string, callback: () => void): void;
+    /**
+     * @deprecated Use WA.room.onLeaveZone instead
+     */
+    onLeaveZone(name: string, callback: () => void): void;
+};
+export declare type WorkAdventureApi = typeof wa;
+declare global {
+    interface Window {
+        WA: WorkAdventureApi;
+    }
+    let WA: WorkAdventureApi;
+}
+export {};

package/iframe_api.js

@@ -0,0 +1 @@
+// This file is voluntarily empty.

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@workadventure/iframe-api-typings",
+  "version": "v1.5.0",
+  "description": "Typescript typings for WorkAdventure iFrame API",
+  "main": "iframe_api.js",
+  "types": "iframe_api.d.ts",
+  "repository": "https://github.com/thecodingmachine/workadventure/",
+  "author": "David Négrier <d.negrier@thecodingmachine.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}