bc-stubs 96.0.0

package/bc/Scripts/Speech.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Analyzes a phrase to determine if it is a full emote. A full emote is a phrase wrapped in "()"
+ * @param {string} D - A phrase
+ * @returns {boolean} - Returns TRUE if the current speech phrase is a full emote (all between parentheses)
+ */
+declare function SpeechFullEmote(D: string): boolean;
+/**
+ * Returns the gag level corresponding to the given effect array, or 0 if the effect array contains no gag effects
+ * @param {readonly EffectName[]} Effect - The effect to lookup the gag level for
+ * @return {number} - The gag level corresponding to the given effects
+ */
+declare function SpeechGetEffectGagLevel(Effect: readonly EffectName[]): number;
+/**
+ * Gets the cumulative gag level of an asset group. Each gagging effect has a specific numeric value. The following
+ * Effect arrays are used for the calculation:
+ *     - Item.Property.Effect
+ *     - Item.Asset.Effect
+ *     - Item.Asset.Group.Effect
+ * @param {Character} C - The character, whose assets are used for the check
+ * @param {readonly AssetGroupItemName[]} AssetGroups - The name of the asset groups to look through
+ * @returns {number} - Returns the total gag effect of the character's assets
+ */
+declare function SpeechGetGagLevel(C: Character, AssetGroups: readonly AssetGroupItemName[]): number;
+/**
+ * Gets the cumulative gag level of a character
+ * @param {Character} C - The character, whose assets are used for the check
+ * @param {boolean} [NoDeaf=false] - Whether or not deafness affects the dialogue
+ * @returns {number} - Returns the total gag effect of the character's assets
+ */
+declare function SpeechGetTotalGagLevel(C: Character, NoDeaf?: boolean): number;
+/**
+ * Processes the character's speech, anything between parentheses isn't touched. Effects alter the speech differently according to a character's language. Effects that can be applied are the following: gag talk, baby talk and stuttering.
+ * @param {Character} C - The character, whose dialog might need to be altered
+ * @param {string} CD - The character's dialog to alter
+ * @param {boolean} [NoDeaf=false] - Whether or not deafness affects the dialogue
+ * @returns {string} - Returns the dialog after speech effects were processed (Garbling, Stuttering, Baby talk)
+ */
+declare function SpeechGarble(C: Character, CD: string, NoDeaf?: boolean): string;
+declare function sfc32(a: any, b: any, c: any, d: any): () => number;
+/**
+ * A PRNG(Pseudo random number generator) helper to generate random number sequence by seed.
+ * Stole this function and the function below from {@link https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript stackoverflow}
+ * @param {number} a - seed 1
+ * @param {number} b - seed 2
+ * @param {number} c - seed 3
+ * @param {number} d - seed 4
+ * @returns {() => number} - The function where it could be used to do PRNG magic.
+ */
+declare function sfc32(a: number, b: number, c: number, d: number): () => number;
+/**
+ * Random seeding tool to generate random seeding sequence that is able to be used.
+ * This allows the random result always be the same when the seed is the same.
+ * (This implementation is needed because dialog refreshes every frame, we have to generate garbled text that are the same.)
+ * (Otherwise it will just keep flashing and changing the text.)
+ *
+ * @param {string} seed - The seed to generate random numbers.
+ * @returns {() => number} - The function where it could be used to do PRNG magic.
+ */
+declare function randomSeeding(seed: string): () => number;
+/**
+ * Test if the current character parsed in is a Chinese character, and client user is using Chinese.
+ * This is to prevent garbling Japanese kanji.
+ * But for chatroom use case where two clients may have different languages
+ * I don't have a definite solution yet, so let's do this for now to resolve the options not showing up first.
+ * @param {string} character
+ * @returns {boolean} - true if is Chinese character, false otherwise.
+ */
+declare function isChineseCharacter(character: string): boolean;
+/**
+ * Get the character and determine if it is a Chinese character, if it does, do random garbling according to the gagLevel.
+ * This is only a hotfix for the issue where Chinese characters are not displayed because they are not properly garbled,
+ * when showing as options.
+ *
+ * @param {string} character - The character needs to be garbled.
+ * @param {number} gagLevel - Gag level.
+ *
+ * @return {string} - The character that being garbled.
+ */
+declare function doChineseGarbling(character: string, gagLevel: number): string;
+/**
+ * A helper method to check if the character parsed in is one of the following: ' .?!~-。？！，'
+ * Note: last 4 punctuations are commonly used in CJK languages.
+ * @param {string} character - The character needs to be checked.
+ * @returns {boolean} - true if containing one of the following: ' .?!~-', otherwise false.
+ */
+declare function isStandardPunctuationOrSpace(character: string): boolean;
+/**
+ * A helper method to check if the character parsed in is one of the following: ' .?!~-_'"。？！，'
+ * This one was created for lower gag levels or baby talk. So any and all punction can be added to it.
+ * @param {string} character - The character needs to be checked.
+ * @returns {boolean} - true if containing one of the following: ' .?!~-_'"。？！，', otherwise false.
+ */
+declare function isAnyPunctuationOrSpace(character: string): boolean;
+/**
+ * Helper method to strip diacritics from characters.
+ * @param {string} character - character that needs to be stripped.
+ * @param {Number} gagEffect - The current gag effect level.
+ * @returns {string} - character that being stripped after garbling.
+ */
+declare function stripDiacriticsFromCharacter(character: string, gagEffect: number): string;
+/**
+ * check if the character is one of the following: áàãâéèêíìîõóòôúùûñç
+ * @param {string} character - The character needs to be checked.
+ * @returns {boolean} - true if is one of the above, otherwise false.
+ */
+declare function isAccentedOrLatinCharacter(character: string): boolean;
+/**
+ * The core of the speech garble function, usable without being tied to a specific character
+ * @param {number} GagEffect - The gag level of the speech
+ * @param {string} CD - The character's dialog to alter
+ * @param {boolean} IgnoreOOC
+ * @return {string} - Garbled text
+ */
+declare function SpeechGarbleByGagLevel(GagEffect: number, CD: string, IgnoreOOC?: boolean): string;
+/**
+ * Makes the character stutter if she has a vibrating item and/or is aroused. Stuttering based on arousal is toggled in the character's settings.
+ * @param {Character} C - The character, whose dialog might need to be altered
+ * @param {string} CD - The character's dialog to alter
+ * @returns {string} - Returns the dialog after the stuttering factor was applied
+ */
+declare function SpeechStutter(C: Character, CD: string): string;
+/**
+ * Makes the character talk like a Baby when she has drunk regression milk
+ * @param {Character} C - The character, whose dialog needs to be altered
+ * @param {string} CD - The character's dialog to alter
+ * @returns {string} - Returns the dialog after baby talk was applied
+ */
+declare function SpeechBabyTalk(C: Character, CD: string): string;
+/**
+ * Anonymize character names from a string, replacing them with "Someone".
+ *
+ * Used as part of sensory-deprivation processing.
+ *
+ * @param {string} msg
+ * @param {readonly Character[]} characters
+ */
+declare function SpeechAnonymize(msg: string, characters: readonly Character[]): string;
+declare const chineseRegex: RegExp;
+declare const chineseRandomGarbledSound: string[];
+/**
+ * A lookup mapping the gag effect names to their corresponding gag level numbers.
+ * @type {Record<GagEffectName, number>}
+ * @constant
+ */
+declare var SpeechGagLevelLookup: Record<GagEffectName, number>;

package/bc/Scripts/Struggle.d.ts

@@ -0,0 +1,357 @@
+/**
+ * Get the list of struggle minigames.
+ */
+declare function StruggleGetMinigames(): [StruggleKnownMinigames, StruggleMinigame][];
+/**
+ * Main handler for drawing the struggle minigame screen
+ *
+ * This function is responsible for drawing either the minigame themselves, or
+ * the minigame selection screen if it's not yet running.
+ *
+ * @param {Character} C
+ * @returns {boolean} Whether the draw handler ran
+ */
+declare function StruggleMinigameDraw(C: Character): boolean;
+/**
+ * Gets the correct label for the current operation (struggling, removing, swaping, adding, etc.)
+ * @param {Character} C - The character who acts
+ * @param {Item} PrevItem - The first item that's part of the action
+ * @param {Item} NextItem - The second item that's part of the action
+ * @returns {string} - The appropriate dialog option
+ */
+declare function StruggleProgressGetOperation(C: Character, PrevItem: Item, NextItem: Item): string;
+/**
+ * We can loosen if the item allows it, if enough time was spent and if the challenge is between 1 and 9
+ * @returns {boolean} - TRUE if it's allowed
+ */
+declare function StruggleAllowLoosen(): boolean;
+/**
+ * Handles the minigames' KeyDown event.
+ *
+ * Only applicable for the Strength minigame.
+ *
+ * Increases or decreases the struggle mini-game, if a/A or s/S were pressed.
+ * @returns {void} - Nothing
+ */
+declare function StruggleKeyDown(): void;
+/**
+ * Handles the minigames' Click event, whether on the selection screen or in the minigame themselves.
+ *
+ * @returns {boolean} - Nothing
+ */
+declare function StruggleMinigameClick(): boolean;
+/**
+ * Handle the common progress and drawing of the minigame
+ *
+ * This function draws the minigame common UI, and updates the progress if it should
+ * do so automatically.
+ *
+ * @param {number} [Offset]
+ */
+declare function StruggleMinigameDrawCommon(Offset?: number): void;
+/**
+ * Check if the minigame has been interrupted and we should bail out
+ *
+ * @param {Character} C
+ * @returns {boolean}
+ */
+declare function StruggleMinigameCheckCancel(C: Character): boolean;
+/**
+ * Helper used to tell if something interrupted the minigame.
+ * @param {Character} C
+ * @returns {boolean}
+ */
+declare function StruggleMinigameWasInterrupted(C: Character): boolean;
+/**
+ * Handles making the character's expression when struggling.
+ *
+ * @param {boolean} [Decrease] - Whether the game progressed or not that tick.
+ */
+declare function StruggleMinigameHandleExpression(Decrease?: boolean): void;
+/**
+ * Helper function that handles checking and completing the minigame
+ *
+ * @param {Character} C - The character to check for progress.
+ */
+declare function StruggleProgressCheckEnd(C: Character): void;
+/**
+ * Check if there's a struggling minigame started.
+ *
+ * @returns {boolean}
+ */
+declare function StruggleMinigameIsRunning(): boolean;
+/**
+ * Starts the given struggle minigame.
+ *
+ * This function initializes the common state and calls the requested minigame
+ * setup function.
+ *
+ * @param {Character} C - The character currently doing the struggling, either on itself (ie. as Player), or on someone else.
+ * @param {StruggleKnownMinigames} MiniGame - The minigame to start
+ * @param {Item | null} PrevItem - The item currently being present on the character, or null if none
+ * @param {Item} NextItem - The item currently being added on the character, or null if it's a removal
+ * @param {StruggleCompletionCallback} Completion - A callback that will be called when the minigame ends
+ */
+declare function StruggleMinigameStart(C: Character, MiniGame: StruggleKnownMinigames, PrevItem: Item | null, NextItem: Item, Completion: StruggleCompletionCallback): void;
+/**
+ * Stop the struggle minigame and reset it so it can be reentered.
+ *
+ * If the game was already played a bit, it will also log the failure in chat.
+ *
+ * @returns {void}
+ */
+declare function StruggleMinigameStop(): void;
+/**
+ * Perform setup for the Strength minigame.
+ *
+ * Called by StruggleMinigameStart. Calculates the challenge level based on the
+ * base item difficulty, the skill of the rigger and the escapee and modified,
+ * if the escapee is bound in a way.
+ *
+ * @param {Character} C - The character who tries to struggle
+ * @param {Item} PrevItem - The item, the character wants to struggle out of
+ * @param {Item} [NextItem] - The item that should substitute the first one
+ * @returns {void} - Nothing
+ */
+declare function StruggleStrengthSetup(C: Character, PrevItem: Item, NextItem?: Item): void;
+/**
+ * Strength minigame main drawing routine.
+ *
+ * @param {Character} C - The character for whom the struggle dialog is drawn. That can be the player or another character.
+ * @returns {void} - Nothing
+ */
+declare function StruggleStrengthDraw(C: Character): void;
+/**
+ * Handle events for the Strength minigame
+ *
+ * @param {"Click"|"KeyDown"} EventType
+ * @returns {void}
+ */
+declare function StruggleStrengthHandleEvent(EventType: "Click" | "KeyDown"): void;
+/**
+ * Advances the Struggle minigame progress
+ *
+ * The change of facial expressions during struggling is done here
+ * @param {boolean} [Decrease] - If set to true, the progress is decreased
+ * @returns {void} - Nothing
+ */
+declare function StruggleStrengthProcess(Decrease?: boolean): void;
+/**
+ * Performs the difficulty calculation for the Strength minigame
+ *
+ * This function calculates the challenge level based on the base item
+ * difficulty, the skill of the rigger and the escapee, accounting for the
+ * escapee being bound in a way.
+ *
+ * @param {Character} C - The character who tries to struggle
+ * @param {Item} PrevItem - The item, the character wants to struggle out of
+ * @param {Item} [NextItem] - The item that should substitute the first one
+ * @returns {{difficulty: number; auto: number; timer: number; }} - Nothing
+ */
+declare function StruggleStrengthGetDifficulty(C: Character, PrevItem: Item, NextItem?: Item): {
+    difficulty: number;
+    auto: number;
+    timer: number;
+};
+/**
+ * Loosen minigame main drawing routine.
+ * @param {Character} C - The character for whom the struggle dialog is drawn. That can be the player or another character.
+ * @returns {void} - Nothing
+ */
+declare function StruggleLoosenDraw(C: Character): void;
+/**
+ * Loosen minigame main setup.
+* @returns {void} - Nothing
+*/
+declare function StruggleLoosenSetup(): void;
+/**
+ * Handle events for the loosen minigame
+ * @param {"Click"|"KeyDown"} EventType
+ * @returns {void}
+ */
+declare function StruggleLoosenHandleEvent(EventType: "Click" | "KeyDown"): void;
+/**
+ * Starts the dialog progress bar for struggling out of bondage and keeps the items that needs to be added / swapped / removed.
+ * First the challenge level is calculated based on the base item difficulty, the skill of the rigger and the escapee and modified, if
+ * the escapee is bound in a way. Also blushing and drooling, as well as playing a sound is handled in this function.
+ * @param {Character} C - The character who tries to struggle
+ * @param {Item} PrevItem - The item, the character wants to struggle out of
+ * @param {Item} [NextItem] - The item that should substitute the first one
+ * @returns {void} - Nothing
+ */
+declare function StruggleFlexibilitySetup(C: Character, PrevItem: Item, NextItem?: Item): void;
+/**
+ * Draw the Flexibility minigame
+ * @param {Character} C - The character for whom the struggle dialog is drawn. That can be the player or another character.
+ * @returns {void} - Nothing
+ */
+declare function StruggleFlexibilityDraw(C: Character): void;
+/**
+ * Checks for collision with the mouse
+ * @returns {boolean} - Result of check
+ */
+declare function StruggleFlexibilityCheck(): boolean;
+/**
+ * Handle events for the Flexibility minigame
+ *
+ * @param {"Click"|"KeyDown"} EventType
+ * @returns {void}
+ */
+declare function StruggleFlexibilityHandleEvent(EventType: "Click" | "KeyDown"): void;
+/**
+ * Advances the Flexibility minigame progress
+ *
+ * @param {boolean} [Decrease] - If set to true, the progress is decreased
+ * @returns {void} - Nothing
+ */
+declare function StruggleFlexibilityProcess(Decrease?: boolean): void;
+/**
+ * Starts the dialog progress bar for struggling out of bondage and keeps the items that needs to be added / swapped / removed.
+ * First the challenge level is calculated based on the base item difficulty, the skill of the rigger and the escapee and modified, if
+ * the escapee is bound in a way. Also blushing and drooling, as well as playing a sound is handled in this function.
+ * @param {Character} C - The character who tries to struggle
+ * @param {Item} PrevItem - The item, the character wants to struggle out of
+ * @param {Item} [NextItem] - The item that should substitute the first one
+ * @returns {void} - Nothing
+ */
+declare function StruggleDexteritySetup(C: Character, PrevItem: Item, NextItem?: Item): void;
+/**
+ * Draw the struggle dialog
+ * @param {Character} C - The character for whom the struggle dialog is drawn. That can be the player or another character.
+ * @returns {void} - Nothing
+ */
+declare function StruggleDexterityDraw(C: Character): void;
+/**
+ * Handle events for the Flexibility minigame
+ *
+ * @param {"Click"|"KeyDown"} EventType
+ * @returns {void}
+ */
+declare function StruggleDexterityHandleEvent(EventType: "Click" | "KeyDown"): void;
+/**
+ * Advances the Dexterity minigame progress
+ *
+ * @returns {void} - Nothing
+ */
+declare function StruggleDexterityProcess(): void;
+/**
+ * Handles events for the LockPicking minigame
+ * @param {"Click"|"KeyDown"} EventType
+ * @returns {void} - Nothing
+ */
+declare function StruggleLockPickHandleEvent(EventType: "Click" | "KeyDown"): void;
+/**
+ * Advances the lock picking dialog
+ * @returns {void} - Nothing
+ */
+declare function StruggleLockPickProcess(): void;
+/**
+ * Draw the lockpicking dialog
+ * @param {Character} C - The character for whom the lockpicking dialog is drawn. That can be the player or another character.
+ * @returns {void} - Nothing
+ */
+declare function StruggleLockPickDraw(C: Character): void;
+/**
+ * Gets the correct label for the current operation (struggling, removing, swaping, adding, etc.)
+ * @param {Character} C - The character who acts
+ * @param {Item} Item - The item that's part of the action
+ * @returns {string} - The appropriate dialog option
+ */
+declare function StruggleLockPickProgressGetOperation(C: Character, Item: Item): string;
+/**
+ * Starts the dialog progress bar for picking a lock
+ * First the challenge level is calculated based on the base lock difficulty, the skill of the rigger and the escapee
+ * @param {Character} C - The character who tries to struggle
+ * @param {Item} Item - The item, the character wants to unlock
+ * @returns {void} - Nothing
+ */
+declare function StruggleLockPickSetup(C: Character, Item: Item): void;
+/** @type {null | number[]} */
+declare var StruggleLockPickOrder: null | number[];
+/** @type {null | boolean[]} */
+declare var StruggleLockPickSet: null | boolean[];
+/** @type {null | boolean[]} */
+declare var StruggleLockPickSetFalse: null | boolean[];
+/** @type {null | number[]} */
+declare var StruggleLockPickOffset: null | number[];
+/** @type {null | number[]} */
+declare var StruggleLockPickOffsetTarget: null | number[];
+/** @type {null | number[]} */
+declare var StruggleLockPickImpossiblePins: null | number[];
+declare var StruggleLockPickProgressSkill: number;
+declare var StruggleLockPickProgressSkillLose: number;
+declare var StruggleLockPickProgressChallenge: number;
+declare var StruggleLockPickProgressMaxTries: number;
+declare var StruggleLockPickProgressCurrentTries: number;
+declare var StruggleLockPickSuccessTime: number;
+declare var StruggleLockPickFailTime: number;
+declare var StruggleLockPickArousalTick: number;
+declare var StruggleLockPickArousalTickTime: number;
+declare var StruggleLockPickArousalText: string;
+declare var StruggleLockPickFailTimeout: number;
+declare var StruggleLockPickTotalTries: number;
+declare var StruggleProgressStruggleCount: number;
+declare var StruggleProgressAuto: number;
+declare var StruggleProgressOperation: string;
+declare var StruggleProgressSkill: number;
+declare var StruggleProgressLastKeyPress: number;
+declare var StruggleProgressChallenge: number;
+declare var StruggleLoosenSpeed: number;
+declare var StruggleLoosenAngle: number;
+declare var StruggleLoosenHoleAngle: number;
+/**
+ * Character expression at the beginning of the minigame; player-only
+ * @type {Partial<Record<ExpressionGroupName, ExpressionName>> | undefined}
+ */
+declare var StruggleExpressionStore: Partial<Record<ExpressionGroupName, ExpressionName>> | undefined;
+/**
+ * The struggle minigame progress
+ *
+ * -1 means there's no game running. 0 and StruggleProgressCurrentMinigame
+ * indicates the player hasn't selected a game yet.
+ *
+ * @type {number}
+ */
+declare let StruggleProgress: number;
+/**
+ * The minigame currently running
+ * @type {StruggleKnownMinigames | ""}
+ */
+declare var StruggleProgressCurrentMinigame: StruggleKnownMinigames | "";
+/**
+ * The item worn at the beginning of the minigame
+ * @type {Item | null}
+ */
+declare var StruggleProgressPrevItem: Item | null;
+/**
+ * The item that should be worn at the end of the minigame
+ * @type {Item | null}
+ */
+declare var StruggleProgressNextItem: Item | null;
+/**
+ * A function called when the struggle minigame completes
+ * @type {StruggleCompletionCallback}
+ */
+declare var StruggleExitFunction: StruggleCompletionCallback;
+/** @type {null | { X: number, Y: number, Size: number, Velocity: number }[]} */
+declare var StruggleProgressFlexCircles: null | {
+    X: number;
+    Y: number;
+    Size: number;
+    Velocity: number;
+}[];
+declare var StruggleProgressFlexTimer: number;
+declare var StruggleProgressFlexMaxX: number;
+declare var StruggleProgressFlexMaxY: number;
+declare var StruggleProgressFlexCirclesRate: number;
+declare var StruggleProgressDexTarget: number;
+declare var StruggleProgressDexCurrent: number;
+declare var StruggleProgressDexMax: number;
+declare var StruggleProgressDexDirectionRight: boolean;
+/** @type {Record<string, StruggleMinigame>} */
+declare const StruggleMinigames: Record<string, StruggleMinigame>;
+/**
+ * List of expressions to go through while struggling, keyed by duration
+ * @type {Record<number, Partial<Record<ExpressionGroupName, ExpressionName>>>}
+ */
+declare const StruggleFacesList: Record<number, Partial<Record<ExpressionGroupName, ExpressionName>>>;

package/bc/Scripts/Testing.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Gather all color-layers and -groups absent from their respective .csv files
+ * @returns {[colorLayers: TestingStruct<string>[], colorGroups: TestingStruct<string>[]]}
+ */
+declare function TestingGetMissingColorLayersGroups(): [colorLayers: TestingStruct<string>[], colorGroups: TestingStruct<string>[]];
+/**
+ * Test whether all asset default colors are valid.
+ * @returns {TestingStruct<string[]>[]}
+ */
+declare function TestingValidateDefaultColor(): TestingStruct<string[]>[];
+/**
+ * A module with helper utilities for testing.
+ * Note that this file and its content therein should only be executed when running
+ * the `AssetCheck` test suit, and should therefore *not* be added to `index.html`.
+ *
+ * NOTE: Make sure to declare module-level objects as `var` if they should appear in
+ * the VM context output.
+ */
+/** @type {Set<string>} */
+declare var TestingColorLayers: Set<string>;
+/** @type {Set<string>} */
+declare var TestingColorGroups: Set<string>;
+declare var TestingMisingColorLayers: TestingStruct<string>[];
+declare var TestingMisingColorGroups: TestingStruct<string>[];
+declare var TestingInvalidDefaultColor: TestingStruct<string[]>[];
+declare var TestingModularItemDataLookup: Record<string, ModularItemData>;
+declare var TestingTypedItemDataLookup: Record<string, TypedItemData>;
+declare var TestingVibratingItemDataLookup: Record<string, VibratingItemData>;
+declare var TestingVariableHeightItemDataLookup: Record<string, VariableHeightData>;
+declare var TestingTextItemDataLookup: Record<string, TextItemData>;

package/bc/Scripts/Text.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Finds the text value linked to the tag in the buffer
+ * @param {string} TextTag - Tag for the text to find
+ * @returns {string} - Returns the text associated to the tag, will return a missing tag text if the tag was not found.
+ */
+declare function TextGet(TextTag: string): string;
+/**
+ * Loads the CSV text file of the current screen into the buffer. It will get the CSV from the cache if the file was already fetched from
+ * the server
+ * @param {string} [TextGroup] - Screen for which to load the CSV of
+ * @returns {void} - Nothing
+ */
+declare function TextLoad(TextGroup?: string): void;
+/**
+ * Cache the Module and TextGroup for later use, speeds up first use
+ * @param {string} Module
+ * @param {string} TextGroup
+ */
+declare function TextPrefetch(Module: string, TextGroup: string): void;
+/** @type {TextCache | null} */
+declare let TextScreenCache: TextCache | null;
+/** @type {Map<string, TextCache>} */
+declare const TextAllScreenCache: Map<string, TextCache>;
+/**
+ * A class that can be used to cache a simple key/value CSV file for easy text lookups. Text lookups will be automatically translated to
+ * the game's current language, if a translation is available.
+ */
+declare class TextCache {
+    /**
+     * Creates a new TextCache from the provided CSV file path.
+     * @param {string} path - The path to the CSV lookup file for this TextCache instance
+     * @param {string} [warn] - prefix for warning when key is not found
+     */
+    constructor(path: string, warn?: string);
+    path: string;
+    warn: string;
+    language: string;
+    /** @type {Record<string, string>} */
+    cache: Record<string, string>;
+    /** @type {((cache?: TextCache) => void)[]} */
+    rebuildListeners: ((cache?: TextCache) => void)[];
+    loaded: boolean;
+    /**
+     * Looks up a string from this TextCache. If the cache contains a value for the provided key and a translation is available, the return
+     * value will be automatically translated. Otherwise the EN string will be used. If the cache does not contain a value for the requested
+     * key, the key will be returned.
+     * @param {string} key - The text key to lookup
+     * @returns {string} - The text value corresponding to the provided key, translated into the current language, if available
+     */
+    get(key: string): string;
+    /**
+     * Adds a callback function as a rebuild listener. Rebuild listeners will
+     * be called whenever the cache has completed a rebuild (either after
+     * initial construction, or after a language change).
+     * @param {(cache?: TextCache) => void} callback - The callback to register
+     * @param {boolean} [immediate] - Whether or not the callback should be called on registration
+     * @returns {Function} - A callback function which can be used to unsubscribe the added listener
+     */
+    onRebuild(callback: (cache?: TextCache) => void, immediate?: boolean): Function;
+    /**
+     * Kicks off a build of the text lookup cache
+     * @returns {void} - Nothing
+     */
+    buildCache(): void;
+    /**
+     * Fetches and parses the CSV file for this TextCache
+     * @returns {Promise<string[][]>} - A promise resolving to an array of string arrays, corresponding to lines of CSV values in the CSV
+     * file.
+     */
+    fetchCsv(): Promise<string[][]>;
+    /**
+     * Stores the contents of a CSV file in the TextCache's internal cache
+     * @param {string[][]} lines - An array of string arrays corresponding to lines in the CSV file
+     * @returns {void} - Nothing
+     */
+    cacheLines(lines: string[][]): void;
+    /**
+     * Translates the contents of a CSV file into the current game language
+     * @param {string[][]} lines - An array of string arrays corresponding to lines in the CSV file
+     * @returns {Promise<string[][]>} - A promise resolving to an array of string arrays corresponding to lines in the CSV file with the
+     * values translated to the current game language
+     */
+    translate(lines: string[][]): Promise<string[][]>;
+    /**
+     * Maps lines of a CSV to equivalent CSV lines with values translated according to the corresponding translation file
+     * @param {string[][]} lines - An array of string arrays corresponding to lines in the CSV file
+     * @param {string[]} translations - An array of strings in translation file format (with EN and translated values on alternate lines)
+     * @returns {string[][]} - An array of string arrays corresponding to lines in the CSV file with the
+     * values translated to the current game language
+     */
+    buildTranslations(lines: string[][], translations: string[]): string[][];
+}