@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/avatar/BaseAvatar.js

@@ -0,0 +1,386 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAvatar = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const ClickHandler_1 = require("../hitdetection/ClickHandler");
+const HitSprite_1 = require("../hitdetection/HitSprite");
+const isSetEqual_1 = require("../../util/isSetEqual");
+const AvatarFigurePartType_1 = require("./enum/AvatarFigurePartType");
+const EventManager_1 = require("../events/EventManager");
+const IEventGroup_1 = require("../events/interfaces/IEventGroup");
+const EventOverOutHandler_1 = require("../events/EventOverOutHandler");
+const bodyPartTypes = new Set([
+    AvatarFigurePartType_1.AvatarFigurePartType.Head,
+    AvatarFigurePartType_1.AvatarFigurePartType.Body,
+    AvatarFigurePartType_1.AvatarFigurePartType.LeftHand,
+    AvatarFigurePartType_1.AvatarFigurePartType.RightHand,
+]);
+const headPartTypes = new Set([
+    AvatarFigurePartType_1.AvatarFigurePartType.Head,
+    AvatarFigurePartType_1.AvatarFigurePartType.Face,
+    AvatarFigurePartType_1.AvatarFigurePartType.Eyes,
+    AvatarFigurePartType_1.AvatarFigurePartType.EyeAccessory,
+    AvatarFigurePartType_1.AvatarFigurePartType.Hair,
+    AvatarFigurePartType_1.AvatarFigurePartType.HairBig,
+    AvatarFigurePartType_1.AvatarFigurePartType.FaceAccessory,
+    AvatarFigurePartType_1.AvatarFigurePartType.HeadAccessory,
+    AvatarFigurePartType_1.AvatarFigurePartType.HeadAccessoryExtra,
+]);
+class BaseAvatar extends PIXI.Container {
+    /**
+     * Sprite Z-Index for hit detection
+     */
+    get spritesZIndex() {
+        return this._spritesZIndex;
+    }
+    set spritesZIndex(value) {
+        this._spritesZIndex = value;
+        this._updateSpritesZIndex();
+    }
+    get dependencies() {
+        if (this._dependencies == null)
+            throw new Error("Invalid dependencies in BaseAvatar");
+        return this._dependencies;
+    }
+    set dependencies(value) {
+        this._dependencies = value;
+        this._handleDependenciesSet();
+    }
+    get mounted() {
+        return this._dependencies != null;
+    }
+    get onClick() {
+        return this._clickHandler.onClick;
+    }
+    set onClick(value) {
+        this._clickHandler.onClick = value;
+    }
+    get onDoubleClick() {
+        return this._clickHandler.onDoubleClick;
+    }
+    set onDoubleClick(value) {
+        this._clickHandler.onDoubleClick = value;
+    }
+    get onPointerDown() {
+        return this._clickHandler.onPointerDown;
+    }
+    set onPointerDown(value) {
+        this._clickHandler.onPointerDown = value;
+    }
+    get onPointerUp() {
+        return this._clickHandler.onPointerUp;
+    }
+    set onPointerUp(value) {
+        this._clickHandler.onPointerUp = value;
+    }
+    get onPointerOut() {
+        return this._overOutHandler.onOut;
+    }
+    set onPointerOut(value) {
+        this._overOutHandler.onOut = value;
+    }
+    get onPointerOver() {
+        return this._overOutHandler.onOver;
+    }
+    set onPointerOver(value) {
+        this._overOutHandler.onOver = value;
+    }
+    get lookOptions() {
+        if (this._nextLookOptions != null) {
+            return this._nextLookOptions;
+        }
+        if (this._lookOptions == null)
+            throw new Error("Invalid look options");
+        return this._lookOptions;
+    }
+    set lookOptions(lookOptions) {
+        this._updateLookOptions(this._lookOptions, lookOptions);
+    }
+    get currentFrame() {
+        return this._currentFrame;
+    }
+    set currentFrame(value) {
+        if (value === this._currentFrame) {
+            return;
+        }
+        this._currentFrame = value;
+        this._refreshFrame = true;
+    }
+    constructor(options) {
+        var _a, _b, _c;
+        super();
+        this._avatarDestroyed = false;
+        this._currentFrame = 0;
+        this._clickHandler = new ClickHandler_1.ClickHandler();
+        this._overOutHandler = new EventOverOutHandler_1.EventOverOutHandler();
+        this._refreshFrame = false;
+        this._refreshLook = false;
+        this._sprites = new Map();
+        this._updateId = 0;
+        this._spritesZIndex = 0;
+        this.x = options.position.x;
+        this.y = options.position.y;
+        this.zIndex = options.zIndex;
+        this.spritesZIndex = options.zIndex;
+        this._nextLookOptions = options.look;
+        this._onLoad = options.onLoad;
+        this._skipBodyParts = (_a = options.skipBodyParts) !== null && _a !== void 0 ? _a : false;
+        this._headOnly = (_b = options.headOnly) !== null && _b !== void 0 ? _b : false;
+        this._skipCaching = (_c = options.skipCaching) !== null && _c !== void 0 ? _c : false;
+    }
+    static fromWsproom(wsproom, options) {
+        const avatar = new BaseAvatar({ ...options });
+        avatar.dependencies = {
+            ...wsproom.dependencies,
+            eventManager: EventManager_1.NOOP_EVENT_MANAGER,
+        };
+        return avatar;
+    }
+    getEventGroupIdentifier() {
+        return IEventGroup_1.AVATAR;
+    }
+    destroy() {
+        super.destroy();
+        this._destroyAssets();
+        if (this._cancelTicker != null) {
+            this._cancelTicker();
+        }
+    }
+    _destroyAssets() {
+        var _a;
+        this._sprites.forEach((sprite) => {
+            this._overOutHandler.remove(sprite.events);
+            sprite.destroy();
+        });
+        this._sprites = new Map();
+        (_a = this._container) === null || _a === void 0 ? void 0 : _a.destroy();
+    }
+    _updateSpritesZIndex() {
+        this._sprites.forEach((sprite) => {
+            sprite.zIndex = this.spritesZIndex;
+        });
+    }
+    _updateLookOptions(oldLookOptions, newLookOptions) {
+        if (oldLookOptions == null ||
+            !(0, isSetEqual_1.isSetEqual)(oldLookOptions.actions, newLookOptions.actions) ||
+            oldLookOptions.look != newLookOptions.look ||
+            oldLookOptions.item != newLookOptions.item ||
+            oldLookOptions.effect != newLookOptions.effect ||
+            oldLookOptions.direction != newLookOptions.direction ||
+            oldLookOptions.headDirection != newLookOptions.headDirection) {
+            this._nextLookOptions = newLookOptions;
+            this._refreshLook = true;
+        }
+    }
+    _updatePosition(definition) {
+        if (this._container == null)
+            return;
+        this._container.x = 0;
+        this._container.y = 0;
+    }
+    _updateSprites() {
+        if (this._avatarLoaderResult == null)
+            return;
+        if (this._lookOptions == null)
+            return;
+        const definition = this._avatarLoaderResult.getDrawDefinition(this._lookOptions);
+        this._avatarDrawDefinition = definition;
+        this._updateSpritesWithAvatarDrawDefinition(definition, this.currentFrame);
+        this._updatePosition(definition);
+    }
+    _updateSpritesWithAvatarDrawDefinition(drawDefinition, currentFrame) {
+        var _a;
+        if (this._avatarDestroyed)
+            throw new Error("BaseAvatar was destroyed already");
+        if (!this.mounted)
+            return;
+        this._sprites.forEach((value) => {
+            value.visible = false;
+            value.ignore = true;
+        });
+        (_a = this._container) === null || _a === void 0 ? void 0 : _a.destroy();
+        this._container = new PIXI.Container();
+        this._container.sortableChildren = true;
+        drawDefinition.getDrawDefinition().forEach((part) => {
+            var _a, _b;
+            if (part.kind === "AVATAR_DRAW_PART") {
+                const figurePart = part.type;
+                if (this._skipBodyParts && bodyPartTypes.has(figurePart)) {
+                    return;
+                }
+                if (this._headOnly && !headPartTypes.has(figurePart)) {
+                    return;
+                }
+                const frame = currentFrame % part.assets.length;
+                const asset = part.assets[frame];
+                let sprite = this._sprites.get(asset.fileId);
+                if (sprite == null) {
+                    sprite = this._createAsset(part, asset);
+                    if (sprite != null) {
+                        this._overOutHandler.register(sprite.events);
+                    }
+                }
+                if (sprite == null)
+                    return;
+                sprite.x = asset.x;
+                sprite.y = asset.y;
+                sprite.visible = true;
+                sprite.mirrored = asset.mirror;
+                sprite.ignore = false;
+                sprite.zIndex = this.spritesZIndex + part.z;
+                this._sprites.set(asset.fileId, sprite);
+                (_a = this._container) === null || _a === void 0 ? void 0 : _a.addChild(sprite);
+            }
+            else if (part.kind === "EFFECT_DRAW_PART") {
+                const frame = currentFrame % part.assets.length;
+                const asset = part.assets[frame];
+                let sprite = this._sprites.get(asset.fileId);
+                if (sprite == null) {
+                    sprite = this._createAsset(part, asset);
+                    if (sprite != null) {
+                        this._overOutHandler.register(sprite.events);
+                    }
+                }
+                if (sprite == null)
+                    return;
+                switch (part.ink) {
+                    case 33:
+                        sprite.blendMode = "add";
+                        break;
+                }
+                sprite.x =
+                    asset.x +
+                        (asset.substractWidth != null && asset.substractWidth
+                            ? sprite.texture.width
+                            : 0);
+                sprite.y = asset.y;
+                sprite.visible = true;
+                sprite.mirrored = asset.mirror;
+                sprite.ignore = false;
+                sprite.zIndex = this.spritesZIndex + part.z;
+                this._sprites.set(asset.fileId, sprite);
+                (_b = this._container) === null || _b === void 0 ? void 0 : _b.addChild(sprite);
+            }
+        });
+        this.addChild(this._container);
+    }
+    _createAsset(part, asset) {
+        if (this._avatarLoaderResult == null)
+            throw new Error("Cant create asset when avatar loader result not present");
+        const texture = this._avatarLoaderResult.getTexture(asset.fileId);
+        if (texture == null)
+            return;
+        const sprite = new HitSprite_1.HitSprite({
+            eventManager: this.dependencies.eventManager,
+            mirrored: asset.mirror,
+            group: this,
+        });
+        sprite.hitTexture = texture;
+        sprite.x = asset.x;
+        sprite.y = asset.y;
+        sprite.events.addEventListener("click", (event) => {
+            this._clickHandler.handleClick(event);
+        });
+        sprite.events.addEventListener("pointerdown", (event) => {
+            this._clickHandler.handlePointerDown(event);
+        });
+        sprite.events.addEventListener("pointerup", (event) => {
+            this._clickHandler.handlePointerUp(event);
+        });
+        if (part.kind === "AVATAR_DRAW_PART" &&
+            part.color != null &&
+            part.mode === "colored") {
+            sprite.tint = parseInt(part.color.slice(1), 16);
+        }
+        else {
+            sprite.tint = 0xffffff;
+        }
+        return sprite;
+    }
+    _reloadLook() {
+        if (!this.mounted)
+            return;
+        const lookOptions = this._nextLookOptions;
+        if (lookOptions != null) {
+            const requestId = ++this._updateId;
+            this.dependencies.avatarLoader
+                .getAvatarDrawDefinition({
+                ...lookOptions,
+                initial: true,
+                skipCaching: this._skipCaching,
+            })
+                .then((result) => {
+                if (this._avatarDestroyed)
+                    return;
+                if (requestId !== this._updateId)
+                    return;
+                this._avatarLoaderResult = result;
+                this._lookOptions = lookOptions;
+                this._nextLookOptions = undefined;
+                // Clear sprite cache, since colors could have changed
+                this._destroyAssets();
+                this._updateSprites();
+                this._onLoad && this._onLoad();
+            });
+        }
+    }
+    _updateFrame() {
+        if (this._avatarDrawDefinition == null)
+            return;
+        this._updateSpritesWithAvatarDrawDefinition(this._avatarDrawDefinition, this.currentFrame);
+        this._updatePosition(this._avatarDrawDefinition);
+    }
+    _handleDependenciesSet() {
+        this._reloadLook();
+        if (this._cancelTicker != null) {
+            this._cancelTicker();
+        }
+        if (this._cancelTicker != null) {
+            this._cancelTicker();
+        }
+        this._cancelTicker = this.dependencies.animationTicker.subscribe(() => {
+            if (this._refreshLook) {
+                this._refreshLook = false;
+                this._reloadLook();
+            }
+            if (this._refreshFrame) {
+                this._refreshFrame = false;
+                this._updateFrame();
+            }
+        });
+    }
+}
+exports.BaseAvatar = BaseAvatar;

package/dist/objects/avatar/data/AvatarActionsData.d.ts

@@ -0,0 +1,12 @@
+import { AvatarAction } from "../enum/AvatarAction";
+import { IAvatarActionsData, AvatarActionInfo } from "./interfaces/IAvatarActionsData";
+export declare class AvatarActionsData implements IAvatarActionsData {
+    private _map;
+    private _handItems;
+    constructor(xml: string);
+    static fromUrl(url: string): Promise<AvatarActionsData>;
+    static default(): AvatarActionsData;
+    getHandItemId(actionId: string, id: string): number | undefined;
+    getActions(): AvatarActionInfo[];
+    getAction(id: AvatarAction): AvatarActionInfo | undefined;
+}

package/dist/objects/avatar/data/AvatarActionsData.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarActionsData = void 0;
+const actions_xml_1 = require("./static/actions.xml");
+class AvatarActionsData {
+    constructor(xml) {
+        this._map = new Map();
+        this._handItems = new Map();
+        const document = new DOMParser().parseFromString(xml, "text/xml");
+        document.querySelectorAll(`action`).forEach((action) => {
+            const actionId = action.getAttribute("id");
+            if (actionId == null)
+                return;
+            const info = getAvatarActionInfoFromElement(action);
+            this._map.set(actionId, info);
+            action.querySelectorAll(`param`).forEach((param) => {
+                const paramId = param.getAttribute("id");
+                if (paramId == null)
+                    return;
+                const value = Number(param === null || param === void 0 ? void 0 : param.getAttribute("value"));
+                if (isNaN(value))
+                    return;
+                this._handItems.set(`${actionId}_${paramId}`, value);
+            });
+        });
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarActionsData(text);
+    }
+    static default() {
+        return new AvatarActionsData(atob(actions_xml_1.actionsXml));
+    }
+    getHandItemId(actionId, id) {
+        return this._handItems.get(`${actionId}_${id}`);
+    }
+    getActions() {
+        return Array.from(this._map.values());
+    }
+    getAction(id) {
+        return this._map.get(id);
+    }
+}
+exports.AvatarActionsData = AvatarActionsData;
+function getAvatarActionInfoFromElement(action) {
+    var _a;
+    const id = action.getAttribute("id");
+    const state = action.getAttribute("state");
+    const precedenceString = action.getAttribute("precedence");
+    const geometrytype = action.getAttribute("geometrytype");
+    const activepartset = action.getAttribute("activepartset");
+    const assetpartdefinition = action.getAttribute("assetpartdefinition");
+    const preventsString = action.getAttribute("prevents");
+    const animation = action.getAttribute("animation");
+    const main = action.getAttribute("main");
+    const isdefault = action.getAttribute("isdefault");
+    if (id == null)
+        throw new Error("Invalid id");
+    if (state == null)
+        throw new Error("Invalid state");
+    if (precedenceString == null)
+        throw new Error("Invalid precedence");
+    if (geometrytype == null)
+        throw new Error("Invalid geometry type");
+    if (assetpartdefinition == null)
+        throw new Error("Invalid asset part definition");
+    const prevents = (_a = preventsString === null || preventsString === void 0 ? void 0 : preventsString.split(",")) !== null && _a !== void 0 ? _a : [];
+    const precedence = Number(precedenceString);
+    if (isNaN(precedence))
+        throw new Error("Invalid precedence");
+    return {
+        id,
+        state,
+        precedence,
+        geometrytype,
+        activepartset,
+        assetpartdefinition,
+        prevents,
+        animation: animation === "1",
+        main: main === "1",
+        isdefault: isdefault === "1",
+    };
+}

package/dist/objects/avatar/data/AvatarAnimationData.d.ts

@@ -0,0 +1,14 @@
+import { AvatarAnimationFrame, IAvatarAnimationData } from "./interfaces/IAvatarAnimationData";
+export declare class AvatarAnimationData implements IAvatarAnimationData {
+    private _animationFrames;
+    private _animationFramesCount;
+    constructor(xml: string);
+    static fromUrl(url: string): Promise<AvatarAnimationData>;
+    static default(): AvatarAnimationData;
+    getAnimationFrame(id: string, type: string, frame: number): AvatarAnimationFrame | undefined;
+    getAnimationFrames(id: string, type: string): AvatarAnimationFrame[];
+    getAnimationFramesCount(id: string): number;
+    getAnimationOffset(id: string, geometryId: string, frame: number, direction: number): void;
+    private _getAnimationOffsetFromElement;
+    private _getAnimationFrameFromElement;
+}

package/dist/objects/avatar/data/AvatarAnimationData.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarAnimationData = void 0;
+const animation_xml_1 = require("./static/animation.xml");
+class AvatarAnimationData {
+    constructor(xml) {
+        this._animationFrames = new Map();
+        this._animationFramesCount = new Map();
+        const document = new DOMParser().parseFromString(xml, "text/xml");
+        // `action[id="${id}"] part[set-type="${type}"] frame`
+        document.querySelectorAll("action").forEach((action) => {
+            const actionId = action.getAttribute("id");
+            if (actionId == null)
+                return;
+            action.querySelectorAll("part").forEach((part) => {
+                const setType = part.getAttribute("set-type");
+                if (setType == null)
+                    return;
+                const frames = [];
+                part.querySelectorAll("frame").forEach((frame) => {
+                    const animationFrame = this._getAnimationFrameFromElement(frame);
+                    frames.push(animationFrame);
+                });
+                this._animationFrames.set(`${actionId}_${setType}`, frames);
+            });
+            const partFrameCount = action.querySelectorAll("part:first-child frame")
+                .length;
+            const offsetsFrameCount = action.querySelectorAll(`offsets frame`).length;
+            const frameCount = Math.max(partFrameCount, offsetsFrameCount);
+            this._animationFramesCount.set(actionId, frameCount);
+            action.querySelectorAll(`offsets frame`).forEach((frame) => {
+                const frameId = frame.getAttribute("id");
+                if (frameId == null)
+                    return;
+                frame.querySelectorAll(`directions direction`).forEach((direction) => {
+                    const directionId = direction.getAttribute("id");
+                    if (directionId == null)
+                        return;
+                    direction.querySelectorAll(`bodypart`).forEach((bodypart) => {
+                        const bodyPartId = bodypart.getAttribute("id");
+                        if (bodyPartId == null)
+                            return;
+                    });
+                });
+            });
+        });
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarAnimationData(text);
+    }
+    static default() {
+        return new AvatarAnimationData(atob(animation_xml_1.animationXml));
+    }
+    getAnimationFrame(id, type, frame) {
+        const frames = this._animationFrames.get(`${id}_${type}`);
+        if (frames == null)
+            return;
+        const animationFrameElement = frames[frame];
+        if (animationFrameElement == null)
+            return;
+        return animationFrameElement;
+    }
+    getAnimationFrames(id, type) {
+        var _a;
+        const key = `${id}_${type}`;
+        return (_a = this._animationFrames.get(key)) !== null && _a !== void 0 ? _a : [];
+    }
+    getAnimationFramesCount(id) {
+        var _a;
+        return (_a = this._animationFramesCount.get(id)) !== null && _a !== void 0 ? _a : 0;
+    }
+    getAnimationOffset(id, geometryId, frame, direction) {
+        /*
+        const bodypart = this.querySelector(
+          `action[id="${id}"] offsets frame[id="${frame}"] directions direction[id="${direction}"] bodypart[id="${geometryId}"]`
+        );
+    
+        if (bodypart == null) return { x: 0, y: 0 };
+    
+        const dx = Number(bodypart.getAttribute("dx"));
+        const dy = Number(bodypart.getAttribute("dy"));
+    
+        if (isNaN(dx) || isNaN(dy)) {
+          return { x: 0, y: 0 };
+        }
+    
+        return {
+          x: dx,
+          y: dy,
+        };*/
+    }
+    _getAnimationOffsetFromElement(bodypart) {
+        if (bodypart == null)
+            return { x: 0, y: 0 };
+        const dx = Number(bodypart.getAttribute("dx"));
+        const dy = Number(bodypart.getAttribute("dy"));
+        if (isNaN(dx) || isNaN(dy)) {
+            return { x: 0, y: 0 };
+        }
+        return {
+            x: dx,
+            y: dy,
+        };
+    }
+    _getAnimationFrameFromElement(element) {
+        const number = Number(element.getAttribute("number"));
+        if (isNaN(number))
+            throw new Error("number was NaN");
+        const repeatsString = element.getAttribute("repeats");
+        let repeats = 2;
+        if (repeatsString != null) {
+            repeats = Number(repeatsString);
+        }
+        const assetpartdefinition = element.getAttribute("assetpartdefinition");
+        if (assetpartdefinition == null)
+            throw new Error("assetpartdefinition was null");
+        return {
+            number,
+            assetpartdefinition,
+            repeats,
+        };
+    }
+}
+exports.AvatarAnimationData = AvatarAnimationData;

package/dist/objects/avatar/data/AvatarData.d.ts

@@ -0,0 +1,6 @@
+export declare class AvatarData {
+    protected document: Document;
+    constructor(xml: string);
+    protected querySelectorAll(query: string): Element[];
+    protected querySelector(query: string): Element | null;
+}

package/dist/objects/avatar/data/AvatarData.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarData = void 0;
+class AvatarData {
+    constructor(xml) {
+        this.document = new DOMParser().parseFromString(xml, "text/xml");
+    }
+    querySelectorAll(query) {
+        return Array.from(this.document.querySelectorAll(query));
+    }
+    querySelector(query) {
+        return this.document.querySelector(query);
+    }
+}
+exports.AvatarData = AvatarData;

package/dist/objects/avatar/data/AvatarEffectData.d.ts

@@ -0,0 +1,31 @@
+import { AvatarEffectDirection, AvatarEffectFrameBodypart, AvatarEffectFrameFXPart, AvatarEffectFXAddition, AvatarEffectSprite, AvatarEffectSpriteDirection, IAvatarEffectData } from "./interfaces/IAvatarEffectData";
+export declare class AvatarEffectData implements IAvatarEffectData {
+    private _frameBodyParts;
+    private _frameFxParts;
+    private _sprites;
+    private _additions;
+    private _spriteDirections;
+    private _direction;
+    private _frameCount;
+    private _frameBodyPartsById;
+    private _frameBodyPartByBase;
+    private _frameFxPartsById;
+    constructor(string: string);
+    static fromUrl(url: string): Promise<AvatarEffectData>;
+    getFrameBodyPartByBase(bodyPartId: string, frame: number): AvatarEffectFrameBodypart | undefined;
+    getFrameEffectPart(id: string, frame: number): AvatarEffectFrameFXPart | undefined;
+    getFrameBodyPart(bodyPartId: string, frame: number): AvatarEffectFrameBodypart | undefined;
+    getAddtions(): AvatarEffectFXAddition[];
+    getFrameEffectParts(frame: number): AvatarEffectFrameFXPart[];
+    getDirection(): AvatarEffectDirection | undefined;
+    getFrameBodyParts(frame: number): AvatarEffectFrameBodypart[];
+    getFrameCount(): number;
+    getSprites(): AvatarEffectSprite[];
+    getSpriteDirection(id: string, direction: number): AvatarEffectSpriteDirection | undefined;
+    private _getFXAddition;
+    private _getFXPartFromElement;
+    private _getDirectionFromElement;
+    private _getDirectionSpriteFromElement;
+    private _getEffectSpriteFromElement;
+    private _getFrameBodyPartFromElement;
+}