@workadventure/iframe-api-typings 1.11.3 → 1.12.1

package/Api/Iframe/camera.d.ts

@@ -0,0 +1,46 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import { Observable } from "rxjs";
+import type { WasCameraUpdatedEvent } from "../Events/WasCameraUpdatedEvent";
+export declare class WorkAdventureCameraCommands extends IframeApiContribution<WorkAdventureCameraCommands> {
+    callbacks: {
+        type: "wasCameraUpdated";
+        callback: (event: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            zoom: number;
+        }) => void;
+    }[];
+    /**
+     * Set camera to follow the player.
+     * {@link https://workadventu.re/map-building/api-camera.md#start-following-player | Website documentation}
+     *
+     * @param smooth Smooth transition
+     */
+    followPlayer(smooth?: boolean): void;
+    /**
+     * Set camera to look at given spot. Setting width and height will adjust zoom.
+     * Set lock to true to lock camera in this position.
+     * Set smooth to true for smooth transition.
+     * {@link https://workadventu.re/map-building/api-camera.md#set-spot-for-camera-to-look-at | Website documentation}
+     *
+     * @param {number} x Horizontal position
+     * @param {number} y Vertical position
+     * @param {number} width Width size
+     * @param {number} height Height size
+     * @param {boolean} lock Zoom locked
+     * @param {boolean} smooth Smooth transition
+     */
+    set(x: number, y: number, width?: number, height?: number, lock?: boolean, smooth?: boolean): void;
+    /**
+     * Listens to updates of the camera viewport.
+     * It will trigger for every update of the camera's properties (position or scale for instance).
+     * {@link https://workadventu.re/map-building/api-camera.md#listen-to-camera-updates | Website documentation}
+     *
+     * @returns {Subject<WasCameraUpdatedEvent>} An observable firing event when the camera is updated
+     */
+    onCameraUpdate(): Observable<WasCameraUpdatedEvent>;
+}
+declare const _default: WorkAdventureCameraCommands;
+export default _default;

package/Api/Iframe/chat.d.ts

@@ -0,0 +1,36 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+export declare class WorkadventureChatCommands extends IframeApiContribution<WorkadventureChatCommands> {
+    callbacks: {
+        type: "userInputChat";
+        callback: (event: {
+            message: string;
+        }) => void;
+    }[];
+    /**
+     * Open instantly the chat window.
+     * {@link https://workadventu.re/map-building/api-chat.md#open-the-chat-window | Website documentation}
+     */
+    open(): void;
+    /**
+     * Close instantly the chat window.
+     * {@link https://workadventu.re/map-building/api-chat.md#close-the-chat-window | Website documentation}
+     */
+    close(): void;
+    /**
+     * Sends a message in the chat. The message is only visible in the browser of the current user.
+     * {@link https://workadventu.re/map-building/api-chat.md#sending-a-message-in-the-chat | Website documentation}
+     *
+     * @param {string} message Message to be displayed in the chat
+     * @param {string|undefined} author Name displayed for the author of the message. It does not have to be a real user
+     */
+    sendChatMessage(message: string, author?: string): void;
+    /**
+     * Listens to messages typed by the current user and calls the callback. Messages from other users in the chat cannot be listened to.
+     * {@link https://workadventu.re/map-building/api-chat.md#listening-to-messages-from-the-chat | Website documentation}
+     *
+     * @param {function(string): void} callback Function that will be called when a message is received. It contains the message typed by the user
+     */
+    onChatMessage(callback: (message: string) => void): void;
+}
+declare const _default: WorkadventureChatCommands;
+export default _default;

package/Api/Iframe/controls.d.ts

@@ -0,0 +1,56 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+export declare class WorkadventureControlsCommands extends IframeApiContribution<WorkadventureControlsCommands> {
+    callbacks: never[];
+    /**
+     *  Disable player controls.
+     * {@link https://workadventu.re/map-building/api-controls.md#disabling--restoring-controls | Website documentation}
+     */
+    disablePlayerControls(): void;
+    /**
+     * Restore player controls.
+     * {@link https://workadventu.re/map-building/api-controls.md#disabling--restoring-controls | Website documentation}
+     */
+    restorePlayerControls(): void;
+    /**
+     * Turn off player microphone.
+     * {@link https://workadventu.re/map-building/api-controls.md#turn-off-webcam-or-microphone | Website documentation}
+     */
+    turnOffMicrophone(): void;
+    /**
+     * Turn off player webcam.
+     * {@link https://workadventu.re/map-building/api-controls.md#turn-off-webcam-or-microphone | Website documentation}
+     */
+    turnOffWebcam(): void;
+    /**
+     * Disable player microphone.
+     * {@link https://workadventu.re/map-building/api-controls.md#disabling--restoring-webcam-or-microphone | Website documentation}
+     */
+    disableMicrophone(): void;
+    /**
+     * Restore player microphone.
+     * {@link https://workadventu.re/map-building/api-controls.md#disabling--restoring-webcam-or-microphone | Website documentation}
+     */
+    restoreMicrophone(): void;
+    /**
+     * Disable player webcam.
+     * {@link https://workadventu.re/map-building/api-controls.md#disabling--restoring-webcam-or-microphone | Website documentation}
+     */
+    disableWebcam(): void;
+    /**
+     * Disable player webcam.
+     * {@link https://workadventu.re/map-building/api-controls.md#disabling--restoring-webcam-or-microphone | Website documentation}
+     */
+    restoreWebcam(): void;
+    /**
+     * Disable proximity meetings.
+     * {@link https://workadventu.re/map-building/api-controls.md#disabling--restoring-proximity-meeting | Website documentation}
+     */
+    disablePlayerProximityMeeting(): void;
+    /**
+     * Restore proximity meettings.
+     * {@link https://workadventu.re/map-building/api-controls.md#disabling--restoring-proximity-meeting | Website documentation}
+     */
+    restorePlayerProximityMeeting(): void;
+}
+declare const _default: WorkadventureControlsCommands;
+export default _default;

package/Api/Iframe/nav.d.ts

@@ -0,0 +1,58 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+export declare class CoWebsite {
+    private readonly id;
+    constructor(id: string);
+    close(): Promise<void>;
+}
+export declare class WorkadventureNavigationCommands extends IframeApiContribution<WorkadventureNavigationCommands> {
+    callbacks: never[];
+    /**
+     * Opens the webpage at "url" in your browser, in a new tab.
+     * {@link https://workadventu.re/map-building/api-nav.md#opening-a-web-page-in-a-new-tab | Website documentation}
+     *
+     * @param {string} url Url of the web page
+     */
+    openTab(url: string): void;
+    /**
+     * Opens the webpage at "url" in your browser in place of WorkAdventure. WorkAdventure will be completely unloaded.
+     * {@link https://workadventu.re/map-building/api-nav.md#opening-a-web-page-in-the-current-tab | Website documentation}
+     *
+     * @param {string} url Url of the web page
+     */
+    goToPage(url: string): void;
+    /**
+     * Load the map at url without unloading workadventure.
+     * relative urls: "../subFolder/map.json[#start-layer-name]" global urls: "/_/global/domain/path/map.json[#start-layer-name]"
+     * {@link https://workadventu.re/map-building/api-nav.md#going-to-a-different-map-from-the-script | Website documentation}
+     *
+     * @param {string} url Url of the web page
+     */
+    goToRoom(url: string): void;
+    /**
+     * Opens the webpage at "url" in an iFrame (on the right side of the screen) or close that iFrame.
+     * {@link https://workadventu.re/map-building/api-nav.md#openingclosing-web-page-in-co-websites | Website documentation}
+     *
+     * @param {string} url Url of the web page
+     * @param {boolean|undefined} allowApi  Allows the webpage to use the "IFrame API" and execute script (it is equivalent to putting the openWebsiteAllowApi property in the map)
+     * @param {string|undefined} allowPolicy Grants additional access rights to the iFrame
+     * @param {number|undefined} widthPercent Define the width of the main cowebsite beetween the min size and the max size (70% of the viewport)
+     * @param {number|undefined} position Define in whitch slot the web page will be open
+     * @param {boolean|undefined} closable Allow to close the webpage also you need to close it by the api
+     * @param {boolean|undefined} lazy Add the cowebsite but don't load it
+     * @returns {CoWebsite} The CoWebsite created
+     */
+    openCoWebSite(url: string, allowApi?: boolean, allowPolicy?: string, widthPercent?: number, position?: number, closable?: boolean, lazy?: boolean): Promise<CoWebsite>;
+    /**
+     * Get all opened co-websites with their ids and positions.
+     * {@link https://workadventu.re/map-building/api-nav.md#get-all-co-websites | Website documentation}
+     *
+     * @returns {CoWebsite[]} All Cowebsites
+     */
+    getCoWebSites(): Promise<CoWebsite[]>;
+    /**
+     * @deprecated Use closeCoWebsites instead to close all co-websites
+     */
+    closeCoWebSite(): Promise<void>;
+}
+declare const _default: WorkadventureNavigationCommands;
+export default _default;

package/Api/Iframe/player.d.ts

@@ -0,0 +1,141 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import type { HasPlayerMovedEventCallback } from "../Events/HasPlayerMovedEvent";
+import { WorkadventureProximityMeetingCommands } from "./Player/ProximityMeeting";
+export declare const setPlayerName: (name: string) => void;
+export declare const setPlayerLanguage: (language: string | undefined) => void;
+export declare const setTags: (_tags: string[]) => void;
+export declare const setUserRoomToken: (token: string | undefined) => void;
+export declare const setPlayerId: (_id: number | undefined) => void;
+export declare const setUuid: (_uuid: string | undefined) => void;
+export declare class WorkadventurePlayerCommands extends IframeApiContribution<WorkadventurePlayerCommands> {
+    readonly state: import("./playerState").WorkadventurePlayerStateCommands & {
+        [key: string]: unknown;
+    };
+    callbacks: {
+        type: "hasPlayerMoved";
+        callback: (event: {
+            oldX?: number | undefined;
+            oldY?: number | undefined;
+            x: number;
+            y: number;
+            direction: "left" | "right" | "up" | "down";
+            moving: boolean;
+        }) => void;
+    }[];
+    /**
+     * Get the player name.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-player.md#get-the-player-name | Website documentation}
+     *
+     * @returns {string} Player name
+     */
+    get name(): string;
+    /**
+     * Get the player UUID.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-player.md#get-the-player-uuid | Website documentation}
+     * @deprecated Use WA.player.uuid instead
+     *
+     * @returns {string|undefined} Player UUID
+     */
+    get id(): string | undefined;
+    /**
+     * Get the player id.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-player.md#get-the-player-id | Website documentation}
+     *
+     * @returns {number} Player id
+     */
+    get playerId(): number;
+    /**
+     * Get the player UUID.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-player.md#get-the-player-uuid | Website documentation}
+     *
+     * @returns {string|undefined} Player UUID
+     */
+    get uuid(): string | undefined;
+    /**
+     * Get the player language.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-player.md#get-the-player-language | Website documentation}
+     *
+     * @returns {string} Player language
+     */
+    get language(): string;
+    /**
+     * Get the player tags.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-player.md#get-the-tags-of-the-player | Website documentation}
+     *
+     * @returns {string[]} Player tags
+     */
+    get tags(): string[];
+    /**
+     * Get the player position.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-player.md#get-the-position-of-the-player | Website documentation}
+     *
+     * @returns {Position} Player position
+     */
+    getPosition(): Promise<Position>;
+    /**
+     * Listens to the movement of the current user and calls the callback.
+     * Sends an event when the user stops moving, changes direction and every 200ms when moving in the same direction.
+     * {@link https://workadventu.re/map-building/api-player.md#listen-to-player-movement | Website documentation}
+     *
+     * @param {HasPlayerMovedEventCallback} callback Function that will be called when the current player is moving. It contains the event
+     */
+    onPlayerMove(callback: HasPlayerMovedEventCallback): void;
+    /**
+     * Player will try to find shortest path to the destination point and proceed to move there.
+     * {@link https://workadventu.re/map-building/api-player.md#move-player-to-position | Website documentation}
+     *
+     * @param {number} x Horizontal position
+     * @param {number} y Vertical position
+     * @param {number} speed Speed
+     * @returns {Promise<{ x: number, y: number, cancelled: boolean }>} Promise to give an object with the position and if the move has been cancelled or not
+     */
+    moveTo(x: number, y: number, speed?: number): Promise<{
+        x: number;
+        y: number;
+        cancelled: boolean;
+    }>;
+    /**
+     * This token can be used by third party services to authenticate a player and prove that the player is in a given room.
+     * The token is generated by the administration panel linked to WorkAdventure.
+     * The token is a string and is depending on your implementation of the administration panel.
+     * In WorkAdventure SAAS version, the token is a JWT token that contains information such as the player's room ID and its associated membership ID.
+     *
+     * If you are using the self-hosted version of WorkAdventure and you developed your own administration panel, the token can be anything.
+     * By default, self-hosted versions of WorkAdventure don't come with an administration panel, so the token string will be empty.
+     * {@link https://workadventu.re/map-building/api-player.md#get-the-user-room-token-of-the-player | Website documentation}
+     *
+     * @returns {string|undefined} User room token
+     */
+    get userRoomToken(): string | undefined;
+    /**
+     * Display a thin line around your player's name (the "outline").
+     * {@link https://workadventu.re/map-building/api-player.md#set-the-outline-color-of-the-player | Website documentation}
+     *
+     * @param {number} red
+     * @param {number} green
+     * @param {number} blue
+     * @returns {Promise<void>} Promise to wait to known when the outiline has been displayed
+     */
+    setOutlineColor(red: number, green: number, blue: number): Promise<void>;
+    /**
+     * Remove the thin line around your player's name (the "outline").
+     * {@link https://workadventu.re/map-building/api-player.md#set-the-outline-color-of-the-player | Website documentation}
+     *
+     * @returns {Promise<void>} Promise to await to known when the outline has been removed
+     */
+    removeOutlineColor(): Promise<void>;
+    get proximityMeeting(): WorkadventureProximityMeetingCommands;
+}
+export declare type Position = {
+    x: number;
+    y: number;
+};
+declare const _default: WorkadventurePlayerCommands;
+export default _default;

package/Api/Iframe/playerState.d.ts

@@ -0,0 +1,20 @@
+import { AbstractWorkadventureStateCommands } from "./AbstractState";
+export declare class WorkadventurePlayerStateCommands extends AbstractWorkadventureStateCommands {
+    constructor();
+    callbacks: {
+        type: "setPlayerVariable";
+        callback: (event: {
+            value?: unknown;
+            key: string;
+        }) => void;
+    }[];
+    saveVariable(key: string, value: unknown, options?: {
+        public?: boolean;
+        persist?: boolean;
+        ttl?: number;
+        scope?: "world" | "room";
+    }): Promise<void>;
+}
+export declare const playerState: WorkadventurePlayerStateCommands & {
+    [key: string]: unknown;
+};

package/Api/Iframe/players.d.ts

@@ -0,0 +1,135 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import { Observable } from "rxjs";
+import { RemotePlayer, RemotePlayerInterface, RemotePlayerMoved } from "./Players/RemotePlayer";
+export interface PlayerVariableChanged {
+    player: RemotePlayer;
+    value: unknown;
+}
+export declare class WorkadventurePlayersCommands extends IframeApiContribution<WorkadventurePlayersCommands> {
+    private trackingPlayers;
+    private trackingMovement;
+    callbacks: ({
+        type: "setSharedPlayerVariable";
+        callback: (event: {
+            value?: unknown;
+            playerId: number;
+            key: string;
+        }) => void;
+    } | {
+        type: "addRemotePlayer";
+        callback: (event: {
+            outlineColor?: number | undefined;
+            position: {
+                x: number;
+                y: number;
+            };
+            name: string;
+            playerId: number;
+            variables: Map<string, unknown>;
+            userUuid: string;
+            availabilityStatus: string;
+        }) => void;
+    } | {
+        type: "removeRemotePlayer";
+        callback: (event: number) => void;
+    } | {
+        type: "remotePlayerChanged";
+        callback: (event: {
+            position?: {
+                x: number;
+                y: number;
+            } | undefined;
+            name?: string | undefined;
+            variables?: Map<string, unknown> | undefined;
+            availabilityStatus?: string | undefined;
+            outlineColor?: number | undefined;
+            playerId: number;
+        }) => void;
+    })[];
+    private registerRemotePlayer;
+    /**
+     * Start the tracking players. You need to call this method before being able to listen to players positions.
+     * {@link https://workadventu.re/map-building/api-players.md#enabling-players-tracking | Website documentation}
+     *
+     * ```ts
+     * await WA.players.configureTracking({
+     *     players: true, // Required to use "onPlayerEnters", "onPlayerLeaves", "list" and "get"
+     *     movement: true, // Required to get the player position and use "onPlayerMoves"
+     * })
+     * ```
+     *
+     * @param options
+     */
+    configureTracking(options?: {
+        players?: boolean;
+        movement?: boolean;
+    }): Promise<void>;
+    /**
+     * Listens to a given variable change on all available players.
+     * {@link https://workadventu.re/map-building/api-players.md#listen-to-a-remote-player-variable-changes | Website documentation}
+     *
+     * ```ts
+     * WA.players.onVariableChange("score").subscribe({ player, value } => {
+     *     console.log("Score for player", player.name, "has been updated to", value);
+     * });
+     * ```
+     *
+     * If you are looking to listen for variable changes of only one player, look at `RemotePlayer.onVariableChange` instead.
+     */
+    onVariableChange(variableName: string): Observable<PlayerVariableChanged>;
+    /**
+     * Listens to new remote players.
+     * These will be triggered when a remote player is entering our "zone" (zone ~= viewport)
+     * This means this will NOT be triggered when a remote player enters the map, but when the remote player is
+     * getting visible.
+     * {@link https://workadventu.re/map-building/api-players.md#tracking-players-in-real-time | Website documentation}
+     *
+     * Usage:
+     *
+     * ```
+     * WA.players.onPlayerEnters.subscribe((remotePlayer) => { doStuff(); });
+     * ```
+     */
+    get onPlayerEnters(): Observable<RemotePlayerInterface>;
+    /**
+     * Listens to remote players leaving.
+     * These will be triggered when a remote player is leaving our "zone" (zone ~= viewport)
+     * This means this will be triggered when a remote player leaves the map, but ALSO when the remote player is
+     * walking away and is no longer visible.
+     * {@link https://workadventu.re/map-building/api-players.md#tracking-players-in-real-time | Website documentation}
+     *
+     * Usage:
+     *
+     * ```
+     * WA.players.onPlayerLeaves.subscribe((remotePlayer) => { doCleanupStuff(); });
+     * ```
+     */
+    get onPlayerLeaves(): Observable<RemotePlayerInterface>;
+    /**
+     * Listens to movement from all players who are in our zone (zone ~= viewport)
+     * This means this may NOT be triggered when a remote player moves but is far away from us.
+     * {@link https://workadventu.re/map-building/api-players.md#tracking-players-movement | Website documentation}
+     *
+     * Usage:
+     *
+     * ```
+     * WA.players.onPlayerMoves.subscribe(({ player, newPosition, oldPosition }) => { doStuff(); });
+     * ```
+     */
+    get onPlayerMoves(): Observable<RemotePlayerMoved>;
+    /**
+     * Returns a RemotePlayer by its id.
+     * {@link https://workadventu.re/map-building/api-players.md#getting-a-remote-player-by-id | Website documentation}
+     *
+     * Note: if the same user is connected twice, it will be considered as 2 different players with 2 different IDs.
+     */
+    get(id: number): RemotePlayerInterface | undefined;
+    /**
+     * Returns the list of all nearby remote players.
+     * The list only contains the players in the same zone as the current player (where zone ~= viewport).
+     * {@link https://workadventu.re/map-building/api-players.md#getting-a-list-of-players-around-me | Website documentation}
+     */
+    list(): IterableIterator<RemotePlayerInterface>;
+}
+declare const _default: WorkadventurePlayersCommands;
+export default _default;

package/Api/{iframe → Iframe}/registeredCallbacks.d.ts

@@ -1,8 +1,8 @@
 import { IframeResponseEvent } from "../../Api/Events/IframeEvent";
 export declare const registeredCallbacks: {
-    [K in IframeResponseEvent["type"]]?: (event: Extract<IframeResponseEvent, {
+    [K in IframeResponseEvent["type"]]?: ((event: Extract<IframeResponseEvent, {
         type: K;
-    }>["data"]) => void;
+    }>["data"]) => void)[];
 };
 export declare function apiCallback<T extends IframeResponseEvent["type"]>(callbackData: {
     type: T;

package/Api/Iframe/room.d.ts

@@ -0,0 +1,128 @@
+import { Observable } from "rxjs";
+import { IframeApiContribution } from "./IframeApiContribution";
+import type { WorkadventureRoomWebsiteCommands } from "./website";
+import { WorkadventureAreaCommands } from "./area";
+import { ITiledMap } from "@workadventure/tiled-map-type-guard";
+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: ({
+        type: "enterEvent";
+        callback: (event: {
+            name: string;
+        }) => void;
+    } | {
+        type: "leaveEvent";
+        callback: (event: {
+            name: string;
+        }) => void;
+    } | {
+        type: "enterLayerEvent";
+        callback: (event: {
+            name: string;
+        }) => void;
+    } | {
+        type: "leaveLayerEvent";
+        callback: (event: {
+            name: string;
+        }) => void;
+    })[];
+    /**
+     * @deprecated Use onEnterLayer instead
+     */
+    onEnterZone(name: string, callback: () => void): void;
+    /**
+     * @deprecated Use onLeaveLayer instead
+     */
+    onLeaveZone(name: string, callback: () => void): void;
+    /**
+     * Listens to the position of the current user. The event is triggered when the user enters a given layer.
+     * {@link https://workadventu.re/map-building/api-room.md#detecting-when-the-user-entersleaves-a-layer | Website documentation}
+     *
+     * @param {string} layerName Name of the layer who as defined in Tiled
+     * @returns {Subject<void>} Event subject can be listen by a subscribtion
+     */
+    onEnterLayer(layerName: string): Observable<void>;
+    /**
+     * Listens to the position of the current user. The event is triggered when the user leaves a given layer.
+     * {@link https://workadventu.re/map-building/api-room.md#detecting-when-the-user-entersleaves-a-layer | Website documentation}
+     *
+     * @param {string} layerName Name of the layer who as defined in Tiled
+     * @returns {Subject<void>} Event subject can be listen by a subscribtion
+     */
+    onLeaveLayer(layerName: string): Observable<void>;
+    /**
+     * This methods can be used to show a layer. if layerName is the name of a group layer, show all the layer in that group layer.
+     * {@link https://workadventu.re/map-building/api-room.md#show--hide-a-layer | Website documentation}
+     *
+     * @param {string} layerName Name of the layer/group layer who as defined in Tiled
+     */
+    showLayer(layerName: string): void;
+    /**
+     * This methods can be used to hide a layer. if layerName is the name of a group layer, hide all the layer in that group layer.
+     * {@link https://workadventu.re/map-building/api-room.md#show--hide-a-layer | Website documentation}
+     *
+     * @param {string} layerName Name of the layer/group layer who as defined in Tiled
+     */
+    hideLayer(layerName: string): void;
+    /**
+     * Set the value of the propertyName property of the layer layerName at propertyValue.
+     * If the property doesn't exist, create the property propertyName and set the value of the property at propertyValue.
+     * Note : To unset a property from a layer, use setProperty with propertyValue set to undefined.
+     * {@link https://workadventu.re/map-building/api-room.md#setcreate-properties-in-a-layer | Website documentation}
+     *
+     * @param {string} layerName Name of the layer who as defined in Tiled
+     * @param {string} propertyName Name of the property
+     * @param {string|number|boolean|undefined} propertyValue Value of the property
+     */
+    setProperty(layerName: string, propertyName: string, propertyValue: string | number | boolean | undefined): void;
+    /**
+     * Returns a promise that resolves to the JSON map file.
+     * Check the {@link https://doc.mapeditor.org/en/stable/reference/json-map-format/ | Tiled documentation to learn more about the format of the JSON map}.
+     * {@link https://workadventu.re/map-building/api-room.md#getting-map-data | Website documentation}
+     *
+     * @returns {Promise<ITiledMap>} Map in Tiled JSON format
+     */
+    getTiledMap(): Promise<ITiledMap>;
+    /**
+     * Replace the tile at the x and y coordinates in the layer named layer by the tile with the id tile.
+     * {@link https://workadventu.re/map-building/api-room.md#changing-tiles | Website documentation}
+     *
+     * @param {TileDescriptor[]} tiles Description of a tile
+     */
+    setTiles(tiles: TileDescriptor[]): void;
+    /**
+     * The ID of the current room is available from the WA.room.id property.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-room.md#get-the-room-id | Website documentation}
+     *
+     * @returns {string} Id of the room
+     */
+    get id(): string;
+    /**
+     * The URL of the map is available from the WA.room.mapURL property.
+     * Important: You need to wait for the end of the initialization before accessing.
+     * {@link https://workadventu.re/map-building/api-room.md#get-the-map-url | Website documentation}
+     *
+     * @returns {string} Url of the map
+     */
+    get mapURL(): string;
+    /**
+     * Load a tileset in JSON format from an url and return the id of the first tile of the loaded tileset.
+     * {@link https://workadventu.re/map-building/api-room.md#loading-a-tileset | Website documentation}
+     *
+     * @param {string} url Url of the tileset
+     * @returns {Promise<number>} Promise to return the id of the tileset
+     */
+    loadTileset(url: string): Promise<number>;
+    get website(): WorkadventureRoomWebsiteCommands;
+    get area(): WorkadventureAreaCommands;
+}
+declare const _default: WorkadventureRoomCommands;
+export default _default;

package/Api/Iframe/sound.d.ts

@@ -0,0 +1,21 @@
+import { IframeApiContribution } from "./IframeApiContribution";
+import { Sound } from "./Sound/Sound";
+export declare class WorkadventureSoundCommands extends IframeApiContribution<WorkadventureSoundCommands> {
+    callbacks: never[];
+    /**
+     * Load a sound from an url.
+     *
+     * Please note that loadSound returns an object of the Sound class.
+     *
+     * The Sound class that represents a loaded sound contains two methods: play(soundConfig : SoundConfig|undefined) and stop().
+     *
+     * The parameter soundConfig is optional, if you call play without a Sound config the sound will be played with the basic configuration.
+     * {@link https://workadventu.re/map-building/api-sound.md#load-a-sound-from-an-url | Website documentation}
+     *
+     * @param url
+     * @returns
+     */
+    loadSound(url: string): Sound;
+}
+declare const _default: WorkadventureSoundCommands;
+export default _default;