@strixit/storyscript 0.0.0-stage → 1.0.0

package/dist/src/Engine/Interfaces/trade.d.ts

@@ -0,0 +1,62 @@
+import { IItem } from './item';
+import { IStock } from './stock';
+import { IGame } from './game';
+/**
+ * The base properties to configure a trader of or a container for items in the game.
+ */
+export interface ITrade {
+    /**
+     * The id of the trade, set at runtime.
+     */
+    id?: string;
+    /**
+     * The title as shown to the player in the trade dialog. If the trade is defined
+     * for a person, omitting the name will have StoryScript use the person name for
+     * the trade.
+     */
+    name?: string;
+    /**
+     * The description text of the trade as shown to the player.
+     */
+    text?: string;
+    /**
+     * The amount of credits the trader has in whatever credits are used in the game. When the trader is a person,
+     * the person's currency property will be used to set this value.
+     */
+    currency?: number;
+    /**
+     * True if the items for sale by a person are selected from the items the person is carrying, false if other
+     * items in the game are also included in the collection the items are to be selected from. The selection of
+     * items is done using the initCollection function.
+     */
+    ownItemsOnly?: boolean;
+    /**
+     * This function is executed when the player has bought an item from the trader.
+     * @param game The game object
+     * @param item The item bought
+     */
+    onBuy?(game: IGame, item: IItem): void;
+    /**
+     * This function is executed when the player has sold an item to the trader.
+     * @param game The game object
+     * @param item The item sold
+     */
+    onSell?(game: IGame, item: IItem): void;
+    /**
+     * The collection of items the trader will buy or that can be put in the store.
+     */
+    sell?: IStock;
+    /**
+     * The collection of items the trader has to offer or that can be taken from the store.
+     */
+    buy?: IStock & {
+        /**
+         * This function runs when initiating trade and determines whether the list of items
+         * available for buying should be refreshed. Return true to refresh the lists, false
+         * to keep them as they were.
+         * @param game The game object
+         * @param trade The trader for which to refresh the item lists
+         */
+        initCollection?(game: IGame, trade: ITrade): boolean;
+    };
+}

package/dist/src/Engine/ServiceFactory.d.ts

@@ -0,0 +1,52 @@
+import { IAutoplayService, ICharacterService, ICombatService, ICombinationService, ICommandService, IConversationService, IDataSerializer, IDataService, IDataSynchronizer, IDefinitions, IGame, IGameService, IInterfaceTexts, IItemService, IRules, ISoundService, ITradeService } from '..';
+export declare class ServiceFactory {
+    private static _instance;
+    private static _initialized;
+    private readonly _texts;
+    private readonly _rules;
+    private readonly _definitions;
+    private readonly _registeredEntities;
+    private readonly _dataSerializer;
+    private readonly _dataSynchronizer;
+    private readonly _dataService;
+    private _game;
+    private _gameService;
+    private _conversationService;
+    private _combinationService;
+    private _combatService;
+    private _soundService;
+    private _characterService;
+    private _itemService;
+    private _tradeService;
+    private _autoPlayService;
+    private _commandService;
+    constructor(nameSpace: string, definitions: IDefinitions, registeredEntities: Record<string, Record<string, any>>, rules: IRules, texts: IInterfaceTexts);
+    get AvailableLocations(): {
+        id: any;
+        name: any;
+    }[];
+    static readonly GetInstance: () => ServiceFactory;
+    /**
+     * Initialize the game object and the services. Pass in a game object when it should be controlled
+     * by the UI framework. Vue needs this.
+     * @param game The game object.
+     */
+    init: (game?: IGame) => void;
+    GetGame: () => IGame;
+    GetRules: () => IRules;
+    GetTexts: () => IInterfaceTexts;
+    GetGameService: () => IGameService;
+    GetTradeService: () => ITradeService;
+    GetConversationService: () => IConversationService;
+    GetCharacterService: () => ICharacterService;
+    GetCombinationService: () => ICombinationService;
+    GetDataService: () => IDataService;
+    GetDataSerializer: () => IDataSerializer;
+    GetDataSynchronizer: () => IDataSynchronizer;
+    GetCombatService: () => ICombatService;
+    GetSoundService: () => ISoundService;
+    GetItemService: () => IItemService;
+    GetAutoplayService: () => IAutoplayService;
+    GetCommandService: () => ICommandService;
+    private Get;
+}

package/dist/src/Engine/Services/AutoplayService.d.ts

@@ -0,0 +1,11 @@
+import { IAutoplayService, IAutoplayStep, IDemoMode, IGame, IRules } from '../..';
+export declare class AutoplayService implements IAutoplayService {
+    private _game;
+    private _rules;
+    private _demoTimer;
+    constructor(_game: IGame, _rules: IRules);
+    start: (steps: IAutoplayStep[], callback?: () => void) => void;
+    stop: () => void;
+    startDemoMode: (demoConfig: IDemoMode, restartCallback: () => void) => void;
+    private runAutoplayStep;
+}

package/dist/src/Engine/Services/CharacterService.d.ts

@@ -0,0 +1,21 @@
+import { ICharacter, ICharacterService, ICreateCharacter, ICreateCharacterAttribute, ICreateCharacterAttributeEntry, ICreateCharacterStep, IDataService, IGame, IQuest, IRules } from '../..';
+export declare class CharacterService implements ICharacterService {
+    private readonly _dataService;
+    private readonly _game;
+    private readonly _rules;
+    constructor(_dataService: IDataService, _game: IGame, _rules: IRules);
+    getSheetAttributes: () => string[];
+    setupCharacter: () => ICreateCharacter;
+    limitSheetInput: (value: number, attribute: ICreateCharacterAttribute, entry: ICreateCharacterAttributeEntry) => void;
+    distributionDone: (sheet: ICreateCharacter, step?: ICreateCharacterStep) => boolean;
+    createCharacter: (game: IGame, characterData: ICreateCharacter) => ICharacter;
+    setupLevelUp: () => ICreateCharacter;
+    levelUp: (character: ICharacter) => ICharacter;
+    isSlotUsed: (character: ICharacter, slot: string) => boolean;
+    questStatus: (quest: IQuest) => string;
+    checkEquipment: () => void;
+    private readonly prepareSheet;
+    private readonly checkStep;
+    private readonly processDefaultSettings;
+    private readonly setFinish;
+}

package/dist/src/Engine/Services/CombatService.d.ts

@@ -0,0 +1,16 @@
+import { ICharacter, ICombatService, ICombatSetup, ICombatTurn, IEnemy, IGame, IInterfaceTexts, IItem, IRules } from '../..';
+export declare class CombatService implements ICombatService {
+    private readonly _game;
+    private readonly _rules;
+    private readonly _texts;
+    constructor(_game: IGame, _rules: IRules, _texts: IInterfaceTexts);
+    initCombat: () => void;
+    fight: (combat: ICombatSetup<ICombatTurn>, retaliate?: boolean) => Promise<void> | void;
+    isSelectable: (item: IItem) => boolean;
+    canTarget: (item: IItem, target: IEnemy | ICharacter, character: ICharacter) => boolean;
+    private readonly initCombatRound;
+    private readonly getItems;
+    private readonly getTarget;
+    private readonly getTargetName;
+    private readonly enemyDefeated;
+}

package/dist/src/Engine/Services/CombinationService.d.ts

@@ -0,0 +1,15 @@
+import { ICombinable, ICombinationAction, ICombinationService, ICombineResult, IGame, IInterfaceTexts, IRules } from '../..';
+export declare class CombinationService implements ICombinationService {
+    private readonly _game;
+    private readonly _rules;
+    private readonly _texts;
+    private readonly _combinationActions;
+    constructor(_game: IGame, _rules: IRules, _texts: IInterfaceTexts);
+    get combinationActions(): ICombinationAction[];
+    getCombineClass: (tool: ICombinable) => string;
+    setActiveCombination: (combination: ICombinationAction) => void;
+    tryCombination: (target: ICombinable) => ICombineResult;
+    private readonly performCombination;
+    private readonly isMatch;
+    private readonly removeFeature;
+}

package/dist/src/Engine/Services/CommandService.d.ts

@@ -0,0 +1,24 @@
+import { IAction, IBarrier, IBarrierAction, ICombinationService, ICommandService, IConversationService, IDataService, IDestination, IFeature, IGame, IItem, ILocation, ILocationService, IPerson, ITradeService } from '../..';
+export declare class CommandService implements ICommandService {
+    private _locationService;
+    private _conversationService;
+    private _tradeService;
+    private _combinationService;
+    private _dataService;
+    private _game;
+    private _combinationActions;
+    constructor(_locationService: ILocationService, _conversationService: IConversationService, _tradeService: ITradeService, _combinationService: ICombinationService, _dataService: IDataService, _game: IGame);
+    go: (location: (() => ILocation) | string, saveProgress?: boolean) => void;
+    talk: (person: () => IPerson) => void;
+    answer: (node: string, reply?: string) => void;
+    selectCombination: (combination: string) => void;
+    setTool: (feature: (() => IFeature) | string) => void;
+    combine: (combination: string, target: (() => IFeature) | string, tool?: (() => IFeature) | string) => void;
+    useAction: (action: string | [string, IAction]) => void;
+    useBarrierAction: (destination: string | IDestination, barrier: string | [string, IBarrier], action: string | [string, IBarrierAction]) => void;
+    trade: (trade: string | (() => IPerson)) => void;
+    buy: (item: (() => IItem)) => void;
+    sell: (item: (() => IItem)) => void;
+    private getFeature;
+    private getCombination;
+}

package/dist/src/Engine/Services/ConversationService.d.ts

@@ -0,0 +1,26 @@
+import { IConversationNode, IConversationReply, IConversationService, IGame, IPerson, IRules } from '../..';
+export declare class ConversationService implements IConversationService {
+    private readonly _game;
+    private readonly _rules;
+    constructor(_game: IGame, _rules: IRules);
+    talk: (person: IPerson) => void;
+    answer: (node: IConversationNode, reply: IConversationReply) => void;
+    private readonly loadConversation;
+    private readonly initConversation;
+    private readonly getDefaultReply;
+    private readonly processConversationNodes;
+    private readonly getNewNode;
+    private readonly processReplyNodes;
+    private readonly buildReplies;
+    private readonly checkNodes;
+    private readonly GetNodeValue;
+    private readonly getActiveNode;
+    private readonly initReplies;
+    private readonly processReply;
+    private readonly executeAction;
+    private readonly checkReplyAvailability;
+    private readonly checkReplyRequirements;
+    private readonly setReplyStatus;
+    private readonly questProgress;
+    private readonly getReplyId;
+}

package/dist/src/Engine/Services/DataSerializer.d.ts

@@ -0,0 +1,17 @@
+import { IDataSerializer } from '../..';
+export declare class DataSerializer implements IDataSerializer {
+    private readonly _pristineEntities;
+    private conversationPropertiesToSerialize;
+    constructor(_pristineEntities: Record<string, Record<string, any>>);
+    createSerializableClone: (original: any) => any;
+    restoreObjects: (loaded: any) => any;
+    private readonly buildStructureForSerialization;
+    private processArrayDeletedValuesAndProperties;
+    private readonly restoreArray;
+    private readonly createClone;
+    private readonly getClonedValue;
+    private readonly processDataRecord;
+    private readonly processArray;
+    private readonly skipProperty;
+    private readonly isKeyProperty;
+}

package/dist/src/Engine/Services/DataService.d.ts

@@ -0,0 +1,16 @@
+import { IDataSerializer, IDataService, IDataSynchronizer, IGame, ILocalStorageService, IRules } from '../..';
+export declare class DataService implements IDataService {
+    private _localStorageService;
+    private serializer;
+    private synchronizer;
+    private _rules;
+    private _gameNameSpace;
+    constructor(_localStorageService: ILocalStorageService, serializer: IDataSerializer, synchronizer: IDataSynchronizer, _rules: IRules, _gameNameSpace: string);
+    save: <T>(key: string, value: T) => void;
+    load: <T>(key: string) => T;
+    remove: (key: string) => void;
+    saveGame: (game: IGame, name?: string) => void;
+    getSaveKeys: () => string[];
+    hasGameState: () => boolean;
+    private getKey;
+}

package/dist/src/Engine/Services/DataSynchronizer.d.ts

@@ -0,0 +1,12 @@
+import { IDataSynchronizer } from '../..';
+export declare class DataSynchronizer implements IDataSynchronizer {
+    private _pristineEntities;
+    constructor(_pristineEntities: Record<string, Record<string, any>>);
+    synchronizeEntityData: (entity: any, pristineEntity?: any, parentEntity?: any, pristineParentEntity?: any, parentProperty?: string) => void;
+    private updateDataRecord;
+    private updateArray;
+    private updateArrayElement;
+    private isEntity;
+    private markEntriesAsDeleted;
+    private deleteRemovedEntities;
+}

package/dist/src/Engine/Services/GameService.d.ts

@@ -0,0 +1,28 @@
+import { ICharacterService, ICombinationService, ICreateCharacter, IDataService, IDemoMode, IGame, IGameService, IInterfaceTexts, ILocationService, IRules, ISoundService, PlayState } from '../..';
+export declare class GameService implements IGameService {
+    private readonly _dataService;
+    private readonly _locationService;
+    private readonly _characterService;
+    private readonly _combinationService;
+    private readonly _soundService;
+    private readonly _rules;
+    private readonly _game;
+    private readonly _texts;
+    constructor(_dataService: IDataService, _locationService: ILocationService, _characterService: ICharacterService, _combinationService: ICombinationService, _soundService: ISoundService, _rules: IRules, _game: IGame, _texts: IInterfaceTexts);
+    initDemo: (demoConfig: IDemoMode) => void;
+    init: (restart?: boolean, skipIntro?: boolean) => void;
+    reset: () => void;
+    startNewGame: (characterData: ICreateCharacter) => void;
+    restart: (skipIntro?: boolean) => void;
+    loadGame: (name: string) => void;
+    watchPlayState(callBack: (game: IGame, newPlayState: PlayState, oldPlayState: PlayState) => void): void;
+    private readonly resume;
+    private watchState;
+    private readonly initTexts;
+    private readonly createCharacter;
+    private readonly initGame;
+    private readonly setInterceptors;
+    private readonly initLogs;
+    private readonly initCombinations;
+    private readonly updateHighScore;
+}

package/dist/src/Engine/Services/HelperService.d.ts

@@ -0,0 +1,18 @@
+import { IDefinitions, IEnemy, IGame, IHelpers, IItem } from '../..';
+export declare class HelperService implements IHelpers {
+    private _game;
+    private _definitions;
+    constructor(_game: IGame, _definitions: IDefinitions);
+    randomEnemy: (selector?: (enemy: IEnemy) => boolean) => IEnemy;
+    randomItem: (selector?: (item: IItem) => boolean) => IItem;
+    getItem: (selector: string) => IItem;
+    getEnemy: (selector: string) => IEnemy;
+    rollDice: (compositeOrSides: string | number, dieNumber?: number, bonus?: number) => number;
+    calculateBonus: (person: {
+        items?: IItem[];
+        equipment?: {};
+    }, type: string) => number;
+    getItemFromParty: (item: string | (() => IItem)) => IItem;
+    removeItemFromParty: (item: IItem | (() => IItem)) => void;
+    private find;
+}

package/dist/src/Engine/Services/ItemService.d.ts

@@ -0,0 +1,21 @@
+import { ICharacter, IEnemy, IGame, IGroupableItem, IInterfaceTexts, IItem, IItemService, IRules } from '../..';
+export declare class ItemService implements IItemService {
+    private _game;
+    private _rules;
+    private _texts;
+    constructor(_game: IGame, _rules: IRules, _texts: IInterfaceTexts);
+    getItemName: (item: IItem) => string;
+    pickupItem: (character: ICharacter, item: IItem) => boolean;
+    canGroupItem: (character: ICharacter, group: IGroupableItem<IItem>, item: IGroupableItem<IItem>) => boolean;
+    groupItem: (character: ICharacter, group: IGroupableItem<IItem>, item: IGroupableItem<IItem>) => boolean;
+    splitItemGroup: (character: ICharacter, item: IGroupableItem<IItem>) => void;
+    useItem: (character: ICharacter, item: IItem, target?: IEnemy) => Promise<void> | void;
+    isEquippable: (item: IItem, character?: ICharacter) => boolean;
+    equipItem: (character: ICharacter, item: IItem) => boolean;
+    unequipItem: (character: ICharacter, item: IItem) => boolean;
+    canDrop: (item: IItem) => boolean;
+    dropItem: (character: ICharacter, item: IItem) => void;
+    private makeSlotAvailable;
+    private findAvailableSlot;
+    private unequip;
+}

package/dist/src/Engine/Services/LocalStorageService.d.ts

@@ -0,0 +1,7 @@
+import { ILocalStorageService } from '../..';
+export declare class LocalStorageService implements ILocalStorageService {
+    get: (key: string) => any;
+    set: (key: string, value: any) => void;
+    remove: (key: string) => void;
+    getKeys: (prefix: string) => string[];
+}

package/dist/src/Engine/Services/LocationService.d.ts

@@ -0,0 +1,25 @@
+import { IAction, ICompiledLocation, IDefinitions, IGame, IGameEvents, ILocation, ILocationService, IRules } from '../..';
+export declare class LocationService implements ILocationService {
+    private readonly _definitions;
+    private readonly _rules;
+    private readonly _game;
+    private readonly _gameEvents;
+    constructor(_definitions: IDefinitions, _rules: IRules, _game: IGame, _gameEvents: IGameEvents);
+    init: () => void;
+    changeLocation: (location: string | (() => ILocation), travel: boolean, game: IGame) => void;
+    executeAction: (action: [string, IAction]) => void;
+    loadLocationDescriptions: (game: IGame) => void;
+    initDestinations: (location: ICompiledLocation) => void;
+    processDestinations: (game: IGame) => void;
+    private readonly setupLocations;
+    private readonly addLocationGet;
+    private readonly switchLocation;
+    private readonly markCurrentLocationAsVisited;
+    private readonly initTrade;
+    private readonly addDestination;
+    private readonly playEvents;
+    private readonly processTextFeatures;
+    private readonly selectLocationDescription;
+    private readonly addKeyAction;
+    private getActionIndex;
+}

package/dist/src/Engine/Services/SoundService.d.ts

@@ -0,0 +1,13 @@
+import { IGame, IRules, ISoundPlayer, ISoundService } from '../..';
+export declare class SoundService implements ISoundService {
+    private _game;
+    private _rules;
+    private _musicStopped;
+    constructor(_game: IGame, _rules: IRules);
+    getSounds: () => ISoundPlayer;
+    getCurrentMusic: () => string;
+    private startMusic;
+    private stopMusic;
+    private playSound;
+    private createHash;
+}

package/dist/src/Engine/Services/TradeService.d.ts

@@ -0,0 +1,17 @@
+import { ICharacter, IDefinitions, IGame, IInterfaceTexts, IItem, IItemService, IPerson, IRules, ITrade, ITradeService } from '../..';
+export declare class TradeService implements ITradeService {
+    private readonly _itemService;
+    private readonly _game;
+    private readonly _rules;
+    private readonly _texts;
+    private readonly _definitions;
+    private _activeTrader;
+    constructor(_itemService: IItemService, _game: IGame, _rules: IRules, _texts: IInterfaceTexts, _definitions: IDefinitions);
+    trade: (trade: IPerson | ITrade) => void;
+    canPay: (item: IItem, buyer: ITrade | ICharacter, seller: ITrade | ICharacter) => boolean;
+    actualPrice: (item: IItem, buyer: ITrade | ICharacter, seller: ITrade | ICharacter) => number;
+    displayPrice: (item: IItem, actualPrice: number) => string;
+    buy: (item: IItem, trade: ITrade) => boolean;
+    sell: (item: IItem, trade: ITrade) => boolean;
+    private initTrade;
+}

package/dist/src/Engine/Services/index.d.ts

@@ -0,0 +1,17 @@
+export { AutoplayService } from './AutoplayService';
+export { CharacterService } from './CharacterService';
+export { CombatService } from './CombatService';
+export { CombinationService } from './CombinationService';
+export { CommandService } from './CommandService';
+export { ConversationService } from './ConversationService';
+export { DataSerializer } from './DataSerializer';
+export { DataService } from './DataService';
+export { DataSynchronizer } from './DataSynchronizer';
+export { GameService } from './GameService';
+export { HelperService } from './HelperService';
+export { ItemService } from './ItemService';
+export { LocalStorageService } from './LocalStorageService';
+export { LocationService } from './LocationService';
+export { SoundService } from './SoundService';
+export { TradeService } from './TradeService';
+export * from './sharedFunctions';

package/dist/src/Engine/Services/serializationData.d.ts

@@ -0,0 +1,8 @@
+export interface SerializationData {
+    clone: any;
+    key: string;
+    original: any;
+    originalValue: any;
+    pristine: any;
+    pristineValue: any;
+}

package/dist/src/Engine/Services/sharedFunctions.d.ts

@@ -0,0 +1,21 @@
+import { ICharacter, IDefinitions, IGame, IItem, IParty, StateList } from '../..';
+export declare function hasDescription(entity: {
+    id?: string;
+    description?: string;
+}): boolean;
+export declare function random<T>(type: string, definitions: IDefinitions, selector?: (item: T) => boolean): T;
+export declare function randomList<T>(collection: T[] | ([() => T]), count: number, selector?: (item: T) => boolean): T[];
+export declare function parseFunction<T extends Function>(text: string): T;
+/**
+ * This function creates a new function with the callback embedded. This makes the new function safe for serialization.
+ * @param functionDefinition The main function to make safe for serialization.
+ * @param callback The callback function to embed.
+ * @returns The main function with the callback embedded.
+ */
+export declare function makeSerializeSafe<T extends Function>(functionDefinition: T, callback: Function): T;
+export declare function serializeFunction(value: Function): string;
+export declare function parseGamePropertiesInTemplate(lines: string, game?: IGame): string;
+export declare function selectStateListEntry(game: IGame, stateList: StateList): any;
+export declare function getItemFromParty(party: IParty, item: string | (() => IItem)): IItem;
+export declare function removeItemFromParty(party: IParty, item: IItem | (() => IItem)): void;
+export declare function removeItemFromItemsAndEquipment(character: ICharacter, item: IItem | (() => IItem)): boolean;

package/dist/src/Engine/arrayAndFunctionExtensions.d.ts

@@ -0,0 +1,3 @@
+export declare function addFunctionExtensions(): void;
+export declare function addUniqueId(entity: any): void;
+export declare function addArrayExtensions(): void;

package/dist/src/Engine/defaultTexts.d.ts

@@ -0,0 +1,7 @@
+import { IInterfaceTexts } from '..';
+export declare class DefaultTexts {
+    texts: IInterfaceTexts;
+    format: typeof format;
+    titleCase: (text: string) => string;
+}
+export declare function format(template: string, tokens: string | string[]): string;

package/dist/src/Engine/gameEvents.d.ts

@@ -0,0 +1,10 @@
+import { IGame, IGameEvents } from '..';
+export declare class GameEvents implements IGameEvents {
+    private readonly _eventHandlers;
+    private _game;
+    register: (eventName: string) => void;
+    subscribe: (eventName: string | string[], handler: (game: IGame, eventArguments: any) => void, throwIfUnknown?: boolean) => void;
+    publish: (eventName: string, eventData?: any) => void;
+    setGame: (game: IGame) => void;
+}
+export declare const gameEvents: GameEvents;

package/dist/src/Engine/index.d.ts

@@ -0,0 +1,8 @@
+import { addArrayExtensions, addFunctionExtensions } from './arrayAndFunctionExtensions';
+import { ServiceFactory } from './ServiceFactory';
+export { addArrayExtensions, addFunctionExtensions, ServiceFactory };
+export * from './Interfaces/index';
+export { gameEvents } from './gameEvents';
+export * from './defaultTexts';
+export * from './Services/sharedFunctions';
+export * from './utilityFunctions';

package/dist/src/Engine/stateProperties.d.ts

@@ -0,0 +1,6 @@
+export declare const enum StateProperties {
+    Id = "ss_uniqueId",
+    Added = "ss_added",
+    Deleted = "ss_deleted",
+    Triggered = "ss_triggered"
+}

package/dist/src/Engine/utilityFunctions.d.ts

@@ -0,0 +1,25 @@
+import { EquipmentType, IItem, ILocation, IParty } from '..';
+export declare function compareString(left: string, right: string): boolean;
+export declare function getId(id: Function | string): string;
+export declare function isDataRecord(item: any[]): boolean;
+export declare function getKeyPropertyNames(item: any, includeUniqueIds?: boolean): {
+    first: string;
+    second: string;
+};
+export declare function propertyMatch(first: any, second: any): boolean;
+export declare function getPlural(name: string): string;
+export declare function getSingular(name: string): string;
+export declare function parseHtmlDocumentFromString(document: string): Document;
+export declare function addHtmlSpaces(text: string): string;
+export declare function isEmpty(object: any, property?: string): boolean;
+export declare function equals<T extends {
+    id?: string;
+} | ILocation>(entity: T | string, definition: () => T): boolean;
+export declare function hasItem(party: IParty, item: IItem | string): boolean;
+export declare function createPromiseForCallback<T>(callBack: Function): {
+    promise: Promise<T>;
+    promiseCallback: () => void;
+};
+export declare function wait(timeInMs: number, callBack: Function): Promise<void>;
+export declare function interval(intervalTimeInMs: number, repeat: number, intervalCallback: Function, finalCallback?: Function): Promise<void>;
+export declare function getEquipmentType(slot: EquipmentType | string): string;

package/dist/src/UI/Composables/CustomCursor.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useCustomCursor(uiRoot: Ref<HTMLElement>): void;

package/dist/src/UI/Composables/LocationMap.d.ts

@@ -0,0 +1,26 @@
+import { Ref } from 'vue';
+import { IMap } from '../..';
+export declare function useLocationMap(mapImageRef: Ref<HTMLImageElement>, mapDialogRef: Ref<HTMLDialogElement>): {
+    map: import('vue').ComputedRef<{
+        name: string;
+        mapImage: string;
+        locations: {
+            location: (() => import('../..').ILocation) | string;
+            coords?: string;
+            markerImage?: string;
+            textLabel?: string;
+            markerElement?: HTMLElement;
+        }[];
+        avatarImage?: string;
+        locationNamesAsTextMarkers: boolean;
+        locationMarkerImage?: string;
+        transitionTime?: number;
+        clickable?: boolean;
+        showMarkersOnKeyPress?: string;
+        toggleFullScreen?: boolean;
+    }>;
+    prepareMap: (newMap: IMap, cleanup: boolean) => void;
+    showMap: () => void;
+    toggleFullScreen: () => void;
+    toggleTouchMarkersVisible: () => void;
+};

package/dist/src/UI/Composables/Sound.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+export declare function useSound(musicPlayerRef: Ref<HTMLAudioElement>): {
+    canPlay: Ref<boolean, boolean>;
+    getSoundQueue: () => [number, string][];
+    getCurrentMusic: () => string;
+    soundCompleted: (soundKey: number) => void;
+};

package/dist/src/UI/Composables/TextFeatures.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+export declare function useTextFeatures(descriptionRef: Ref<HTMLDivElement>): {
+    description: Ref<HTMLDivElement, HTMLDivElement>;
+    refreshFeatures: () => void;
+    click: (ev: PointerEvent) => void;
+    mouseOver: (ev: MouseEvent) => void;
+    mouseOut: (ev: MouseEvent) => void;
+};

package/dist/src/UI/Composables/VisualFeatures.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+export declare function useVisualFeatures(imageRef: Ref<HTMLDivElement>): {
+    locationFeatures: Ref<HTMLDivElement, HTMLDivElement>;
+    factor: Ref<number, number>;
+    initFeatures: () => void;
+    prepareFeatures: () => void;
+};

package/dist/src/UI/Composables/index.d.ts

@@ -0,0 +1,7 @@
+import { useCustomCursor } from './CustomCursor';
+import { useLocationMap } from './LocationMap';
+import { usePlayStateWatch } from './playStateWatch';
+import { useSound } from './Sound';
+import { useTextFeatures } from './TextFeatures';
+import { useVisualFeatures } from './VisualFeatures';
+export { useCustomCursor, useLocationMap, usePlayStateWatch, useSound, useTextFeatures, useVisualFeatures };

package/dist/src/UI/Composables/playStateWatch.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function usePlayStateWatch(uiRoot: Ref<HTMLElement>): void;