bc-stubs 96.0.0

package/bc/Screens/Room/Stable/Stable.d.ts

@@ -0,0 +1,236 @@
+declare function StablePlayerIsPony(): boolean;
+declare function StablePlayerIsExamPony(): boolean;
+declare function StablePlayerIsTrainer(): boolean;
+declare function StablePlayerIsExamTrainer(): boolean;
+declare function StablePlayerCanTrainPony(): boolean;
+declare function StablePlayerIsReadyToTrain(): boolean;
+declare function StablePlayerIsNewby(): boolean;
+/**
+ * Check what outfit the player is currently wearing.
+ * @param {"Pony" | "Trainer" | null} Outfit
+ */
+declare function StablePlayerIsWearingOutfit(Outfit: "Pony" | "Trainer" | null): boolean;
+declare function StablePlayerIsCollared(): boolean;
+declare function StablePlayerOtherPony(): boolean;
+declare function StablePlayerIsolation(): boolean;
+declare function StableTrainingExercisesAvailable(): boolean;
+declare function StablePlayerAllowedPonyExamen(): boolean;
+declare function StablePlayerDisallowedPonyExamen(): boolean;
+declare function StablePlayerAllowedTrainerExamen(): boolean;
+declare function StablePlayerDisallowedTrainerExamen(): boolean;
+declare function StableCanHideDice(): boolean;
+/**
+ * Returns TRUE if the player and the current character can play Club Card
+ * @returns {boolean} - Returns TRUE if both aren't restrained
+ */
+declare function StableCanPlayClubCard(): boolean;
+declare function StableLoad(): void;
+declare function StableRun(): void;
+declare function StableClick(): void;
+declare function StableTrialPonyTraining(): void;
+declare function StableTrialTrainerTraining(): void;
+declare function StableTrialTrainerTrainingEnd(): void;
+/**
+ * @param {"PonyExam" | "TrainPony" | "TrainerExam" | "BecomeTrainer" | "WhiskeyRounds"} Fee
+ * @returns {number}
+ */
+declare function StableFeeValue(Fee: "PonyExam" | "TrainPony" | "TrainerExam" | "BecomeTrainer" | "WhiskeyRounds"): number;
+/**
+ * @param {"PonyExam" | "TrainPony" | "TrainerExam" | "BecomeTrainer" | "WhiskeyRounds"} Fee
+ * @returns {boolean}
+ */
+declare function StableCanPayTheFee(Fee: "PonyExam" | "TrainPony" | "TrainerExam" | "BecomeTrainer" | "WhiskeyRounds"): boolean;
+/**
+ * @param {"PonyExam" | "TrainPony" | "TrainerExam" | "BecomeTrainer" | "WhiskeyRounds"} Fee
+ * @returns {void}
+ */
+declare function StablePayTheFee(Fee: "PonyExam" | "TrainPony" | "TrainerExam" | "BecomeTrainer" | "WhiskeyRounds"): void;
+declare function StableCanBecomePony(): void;
+declare function StablePlayerStartTrainingLesson(): void;
+declare function StablePlayerGetTrainingLesson(): void;
+/**
+ * Start Traning Gallop
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingGallop(Behavior: string): void;
+/**
+ * Start Traning Walk
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingWalk(Behavior: string): void;
+/**
+ * Start Traning Dance
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingDance(Behavior: string): void;
+/**
+ * Start Traning Hurdle
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingHurdles(Behavior: string): void;
+declare function StablePlayerTrainingHurdlesEnd(): void;
+/**
+ * Start Traning Treadmill
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingTreadmill(Behavior: string): void;
+/**
+ * Start Traning Strong Treadmill
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingStrongTreadmill(Behavior: string): void;
+/**
+ * Start Traning Carriage
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingCarriage(Behavior: string): void;
+/**
+ * Start Traning Strong Carriage
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingStrongCarriage(Behavior: string): void;
+/**
+ * Start Traning Race
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingRace(Behavior: string): void;
+/**
+ * Start Traning Strong Race
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingStrongRace(Behavior: string): void;
+/**
+ * Start Traning Carrots - MiniGame
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingCarrots(Behavior: string): void;
+declare function StablePlayerTrainingCarrotsEnd(): void;
+/**
+ * Reward for passed
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingPass(Behavior: string): void;
+/**
+ * Guarantee for failed
+ * @param {string} Behavior
+ * @returns {void}
+ */
+declare function StablePlayerTrainingFail(Behavior: string): void;
+declare function StablePlayerOtherPonys(): void;
+declare function StablePlayerToStable(): void;
+declare function StableDressPonyStart(): void;
+declare function StableBecomePonyFin(): void;
+declare function StableTrainingStoped(): void;
+declare function StablePlayerToHerd(): void;
+declare function StableDressBackPlayer(): void;
+declare function StableCheckEquipment(): void;
+declare function StablePlayerWearEquipment(Behavior: any): void;
+declare function StableWearPonyEquipment(C: any): void;
+declare function StablePlayerStartExam(): void;
+declare function StablePlayerExamHurdles(): void;
+declare function StablePlayerExamHurdlesEnd(): void;
+declare function StablePlayerExamRace(): void;
+declare function StablePlayerExamDressage(): void;
+declare function StablePlayerExamPass(): void;
+declare function StablePlayerExamEnd(): void;
+declare function StableCanBecomeTrainer(): void;
+declare function StableBecomeTrainer(): void;
+declare function StableWearTrainerEquipment(C: any): void;
+declare function StableTrainerStart(): void;
+declare function StablePonyWearEquipment(): void;
+declare function StablePonyTraining(probability: any): void;
+declare function StablePonyTrainingHurdles(): void;
+declare function StablePonyTrainingHurdlesEnd(): void;
+declare function StableTrainerWhip(): void;
+declare function StableTrainerWhipEnd(): void;
+/**
+ * @param {null | Character} C
+ * @returns {void}
+ */
+declare function StablePonyStraightens(C: null | Character): void;
+declare function StablePlayerStartTExam(): void;
+declare function StablePlayerTExamKnow(): void;
+declare function StablePlayerTExamWhip(): void;
+declare function StablePlayerTExamWhipEnd(): void;
+declare function StablePlayerTExamHurdles(): void;
+declare function StablePlayerTExamHurdlesEnd(): void;
+declare function StablePlayerTExamPass(): void;
+declare function StablePlayerTExamEnd(): void;
+declare function StableGenericProgressStart(Timer: any, S: any, S2: any, Item: any, Background: any, Character: any, SecondCharacter: any, Stage: any, CurrentDialog: any, CancelStage: any, CancelCurrentDialog: any, Behavior: any, ProgressOperation: any): void;
+declare function StableGenericDrawProgress(): void;
+declare function StableGenericFinished(): void;
+declare function StableGenericCancel(): void;
+declare function StableGenericProgressEnd(): void;
+declare function StableKeyDown(): void;
+/**
+ * @param {boolean} Reverse
+ */
+declare function StableGenericRun(Reverse: boolean): void;
+/**
+ * Returns true if a Appearance Group for Character available
+ * @param {Character} C
+ * @param {AssetGroupName} AppearanceGroup
+ * @returns {boolean}
+ */
+declare function StableCharacterAppearanceGroupAvailable(C: Character, AppearanceGroup: AssetGroupName): boolean;
+declare function StableHideDice(): void;
+/**
+ * When the player starts a club card game
+ * @returns {void} - Nothing
+ */
+declare function StableClubCardStart(): void;
+/**
+ * When the player ends a club card game
+ * @returns {void} - Nothing
+ */
+declare function StableClubCardEnd(): void;
+declare var StableBackground: string;
+/** @type {null | NPCCharacter} */
+declare var StableTrainer: null | NPCCharacter;
+/** @type {null | NPCCharacter} */
+declare var StablePony: null | NPCCharacter;
+declare var StablePonyPass: boolean;
+declare var StablePonyFail: boolean;
+/** @type {Item[]} */
+declare var StablePlayerAppearance: Item[];
+/** @type {"Pony" | "Trainer" | null} */
+declare var StablePlayerOutfitWorn: "Pony" | "Trainer" | null;
+declare var StablePlayerTrainingActiv: boolean;
+declare var StablePlayerTrainingLessons: number;
+declare var StablePlayerTrainingBehavior: number;
+declare var StableTrainerTrainingExercises: number;
+declare var StablePlayerInIsolation: boolean;
+/** @type {null | number} */
+declare var StablePlayerInIsolationStart: null | number;
+/** @type {null | number} */
+declare var StablePlayerInIsolationEnd: null | number;
+declare var StableExamPoint: number;
+declare var StableProgress: number;
+declare var StableSecondProgress: number;
+declare var StableProgressAuto: number;
+declare var StableSecondProgressAuto: number;
+declare var StableProgressClick: number;
+declare var StableProgressLastKeyPress: number;
+declare var StableProgressItem: string;
+declare var StableProgressFinished: boolean;
+declare var StableProgressCharacter: any;
+declare var StableProgressSecondCharacter: any;
+declare var StableProgressEndStage: number;
+declare var StableProgressEndDialog: any;
+declare var StableProgressCancelStage: any;
+declare var StableProgressCancelDialog: any;
+declare var StableProgressBehavior: number;
+declare var StableProgressOperation: any;
+declare var StableProgressStruggleCount: any;

package/bc/Scripts/Activity.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Checks if the current room allows for activities. (They can only be done in certain rooms)
+ * @returns {boolean} - Whether or not activities can be done
+ */
+declare function ActivityAllowed(): boolean;
+/**
+ * Loads the activity dictionary that will be used throughout the game to output messages. Loads from cache first if possible.
+ * @return {void} - Nothing
+ */
+declare function ActivityDictionaryLoad(): void;
+/**
+ * Translates the activity dictionary.
+ * @param {string} CachePath - Path to the language cache.
+ */
+declare function ActivityTranslate(CachePath: string): void;
+/**
+ * Searches in the dictionary for a specific keyword's text
+ * @param {string} KeyWord - Tag of the activity description to search for
+ * @returns {string} - Description associated to the given keyword
+ */
+declare function ActivityDictionaryText(KeyWord: string): string;
+/**
+ * Resolve a group name to the correct group for activities
+ * @param {IAssetFamily} family - The asset family for the named group
+ * @param {AssetGroupItemName} groupname - The name of the group to resolve
+ * @returns {AssetItemGroup | null} - The resolved group
+ */
+declare function ActivityGetGroupOrMirror(family: IAssetFamily, groupname: AssetGroupItemName): AssetItemGroup | null;
+/**
+ * Gets all groups that mirror or are mirrored by the given group name for activities. The returned array includes the
+ * named group.
+ * @param {IAssetFamily} family - The asset family for the named group
+ * @param {AssetGroupName} groupName - The name of the group to resolve
+ * @returns {AssetGroup[]} - The group and all groups from the same family that mirror or are mirrored by it
+ */
+declare function ActivityGetAllMirrorGroups(family: IAssetFamily, groupName: AssetGroupName): AssetGroup[];
+/**
+ * Check if any activities are possible for a character's given group.
+ * @param {Character} char - The character on which the check is done
+ * @param {AssetGroupItemName} groupname - The group to check access on
+ * @returns {boolean} Whether any activity is possible
+ */
+declare function ActivityPossibleOnGroup(char: Character, groupname: AssetGroupItemName): boolean;
+/**
+ * Check whether a given activity can be performed on a group
+ * @param {Character} char - The character being targeted
+ * @param {Activity} act - The activity to consider
+ * @param {AssetGroup} group - The group to check
+ * @returns {boolean} whether that activity's target is valid
+ */
+declare function ActivityHasValidTarget(char: Character, act: Activity, group: AssetGroup): boolean;
+/**
+ * Check that an activity is permitted by an actor's settings.
+ * @param {Activity} activity - The activity to consider
+ * @param {Character|PlayerCharacter} character - The character to check with
+ * @param {boolean} onOther - Whether we look at doing to or being done on
+ * @returns {boolean} whether the activity is permitted
+ */
+declare function ActivityCheckPermissions(activity: Activity, character: Character | PlayerCharacter, onOther: boolean): boolean;
+/**
+ * Check that that a given prerequisite is met.
+ * @param {ActivityPrerequisite} prereq - The prerequisite to consider
+ * @param {Character|PlayerCharacter} acting - The character performing the activity
+ * @param {Character|PlayerCharacter} acted - The character being acted on
+ * @param {AssetGroup} group - The group being acted on
+ * @returns {boolean} whether the given activity's prerequisite are satisfied
+ */
+declare function ActivityCheckPrerequisite(prereq: ActivityPrerequisite, acting: Character | PlayerCharacter, acted: Character | PlayerCharacter, group: AssetGroup): boolean;
+/**
+ * Check that an activity's prerequisites are met.
+ * @param {Activity} activity - The activity to consider
+ * @param {Character|PlayerCharacter} acting - The character performing the activity
+ * @param {Character|PlayerCharacter} acted - The character being acted on
+ * @param {AssetGroup} group - The group being acted on
+ * @returns {boolean} whether the given activity's prerequisite are satisfied
+ */
+declare function ActivityCheckPrerequisites(activity: Activity, acting: Character | PlayerCharacter, acted: Character | PlayerCharacter, group: AssetGroup): boolean;
+/**
+ *
+ * @param {ItemActivity[]} allowed
+ * @param {Character} acting
+ * @param {Character} acted
+ * @param {ActivityName} needsItem
+ * @param {Activity} activity
+ */
+declare function ActivityGenerateItemActivitiesFromNeed(allowed: ItemActivity[], acting: Character, acted: Character, needsItem: ActivityName, activity: Activity): boolean;
+/**
+ * Builds the allowed activities on a group given the character's settings.
+ * @param {Character} character - The character for which to build the activity dialog options
+ * @param {AssetGroupItemName} groupname - The group to check
+ * @return {ItemActivity[]} - The list of allowed activities
+ */
+declare function ActivityAllowedForGroup(character: Character, groupname: AssetGroupItemName): ItemActivity[];
+/**
+ * Returns TRUE if an activity can be done
+ * @param {Character} C - The character to evaluate
+ * @param {ActivityName} Activity - The name of the activity
+ * @param {AssetGroupItemName} Group - The name of the group
+ * @return {boolean} - TRUE if the activity can be done
+ */
+declare function ActivityCanBeDone(C: Character, Activity: ActivityName, Group: AssetGroupItemName): boolean;
+/**
+ * Calculates the effect of an activity performed on a zone
+ * @param {Character} S - The character performing the activity
+ * @param {Character} C - The character on which the activity is performed
+ * @param {ActivityName | Activity} A - The activity performed
+ * @param {AssetGroupItemName} Z - The group/zone name where the activity was performed
+ * @param {number} [Count=1] - If the activity is done repeatedly, this defines the number of times, the activity is done.
+ * If you don't want an activity to modify arousal, set this parameter to '0'
+ * @param {Asset} [Asset] - The asset used to perform the activity
+ * @return {void} - Nothing
+ */
+declare function ActivityEffect(S: Character, C: Character, A: ActivityName | Activity, Z: AssetGroupItemName, Count?: number, Asset?: Asset): void;
+/**
+ * Used for arousal events that are not activities, such as stimulation events
+ * @param {Character} S - The character performing the activity
+ * @param {Character} C - The character on which the activity is performed
+ * @param {number} Amount - The base amount of arousal to add
+ * @param {AssetGroupItemName} Z - The group/zone name where the activity was performed
+ * @param {number} [Count=1] - If the activity is done repeatedly, this defines the number of times, the activity is done.
+ * If you don't want an activity to modify arousal, set this parameter to '0'
+ * @param {Asset} [Asset] - The asset used to perform the activity
+ * @return {void} - Nothing
+ */
+declare function ActivityEffectFlat(S: Character, C: Character, Amount: number, Z: AssetGroupItemName, Count?: number, Asset?: Asset): void;
+/**
+ * Syncs the player arousal with everyone in chatroom
+ * @param {Character} C - The character for which to sync the arousal data
+ * @return {void} - Nothing
+ */
+declare function ActivityChatRoomArousalSync(C: Character): void;
+/**
+ * Sets the character arousal level and validates the value
+ * @param {Character} C - The character for which to set the arousal progress of
+ * @param {number} Progress - Progress to set for the character (Ranges from 0 to 100)
+ * @return {void} - Nothing
+ */
+declare function ActivitySetArousal(C: Character, Progress: number): void;
+/**
+ * Sets an activity progress on a timer, activities are capped at MaxProgress
+ * @param {Character} C - The character for which to set the timer for
+ * @param {null | Activity} Activity - The activity for which the timer is for
+ * @param {AssetGroupItemName | "ActivityOnOther"} Zone - The target zone of the activity
+ * @param {number} Progress - Progress to set
+ * @param {Asset} [Asset] - The asset used to perform the activity
+ * @return {void} - Nothing
+ */
+declare function ActivitySetArousalTimer(C: Character, Activity: null | Activity, Zone: AssetGroupItemName | "ActivityOnOther", Progress: number, Asset?: Asset): void;
+/**
+ * Draws the arousal progress bar at the given coordinates for every orgasm timer.
+ * @param {number} X - Position on the X axis
+ * @param {number} Y - Position on the Y axis
+ * @return {void} - Nothing
+ */
+declare function ActivityOrgasmProgressBar(X: number, Y: number): void;
+/**
+ * Ends the orgasm early if progress is close or progress is sufficient
+ * @return {void} - Nothing
+ */
+declare function ActivityOrgasmControl(): void;
+/**
+ * Increases the player's willpower when resisting an orgasm.
+ * @param {Character} C - The character currently resisting
+ * @return {void} - Nothing
+ */
+declare function ActivityOrgasmWillpowerProgress(C: Character): void;
+/**
+ * Starts an orgasm for a given character, lasts between 5 to 15 seconds and can be displayed in a chatroom.
+ * @param {Character} C - Character for which an orgasm is starting
+ * @returns {void} - Nothing
+ */
+declare function ActivityOrgasmStart(C: Character): void;
+/**
+ * Triggered when an orgasm needs to be stopped
+ * @param {Character} C - Character for which to stop the orgasm
+ * @param {number} Progress - Arousal level to set the character at once the orgasm ends
+ * @returns {void} - Nothing
+ */
+declare function ActivityOrgasmStop(C: Character, Progress: number): void;
+/**
+ * Generates an orgasm button and progresses in the orgasm mini-game. Handles the resets and success/failures
+ * @param {number} Progress - Progress of the currently running mini-game
+ * @returns {void} - Nothing
+ */
+declare function ActivityOrgasmGameGenerate(Progress: number): void;
+/**
+ * Triggers an orgasm for the player or an NPC which lasts from 5 to 15 seconds
+ * @param {Character} C - Character for which an orgasm was triggered
+ * @param {boolean} [Bypass=false] - If true, this will do a ruined orgasm rather than a real one
+ * @returns {void} - Nothing
+ */
+declare function ActivityOrgasmPrepare(C: Character, Bypass?: boolean): void;
+/**
+ * Sets a character's facial expressions based on their arousal level if their settings allow it.
+ * @param {Character} C - Character for which to set the facial expressions
+ * @param {number} Progress - Current arousal progress
+ * @returns {void} - Nothing
+ */
+declare function ActivityExpression(C: Character, Progress: number): void;
+/**
+ * With time, we increase or decrease the arousal. Validates the result to keep it within 0 to 100 and triggers an orgasm when it reaches 100
+ * @param {Character} C - Character for which the timer is progressing
+ * @param {number} Progress - Progress made (from -100 to 100)
+ * @returns {void} - Nothing
+ */
+declare function ActivityTimerProgress(C: Character, Progress: number): void;
+/**
+ * Set the current vibrator level for drawing purposes
+ * @param {Character} C - Character for which the timer is progressing
+ * @param {0 | 1 | 2 | 3 | 4} Level - Level from 0 to 4 (higher = more vibration)
+ * @returns {void} - Nothing
+ */
+declare function ActivityVibratorLevel(C: Character, Level: 0 | 1 | 2 | 3 | 4): void;
+/**
+ * Calculates the progress one character does on another right away
+ * @param {Character} Source - The character who performed the activity
+ * @param {Character} Target - The character on which the activity was performed
+ * @param {Activity} Activity - The activity performed
+ * @param {AssetGroup} Group - The group on which the activity is performed
+ * @param {Asset} [Asset] - The asset used to perform the activity
+ * @returns {void} - Nothing
+ */
+declare function ActivityRunSelf(Source: Character, Target: Character, Activity: Activity, Group: AssetGroup, Asset?: Asset): void;
+/**
+ * Build the chat tag needed for lookup in ActivityDictionary.csv
+ * @param {Character} character
+ * @param {AssetGroup} group
+ * @param {Activity} activity
+ */
+declare function ActivityBuildChatTag(character: Character, group: AssetGroup, activity: Activity, is_label?: boolean): string;
+/**
+ * Launches a sexual activity for a character and sends the chatroom message if applicable.
+ * @param {Character} actor - Character which is performing the activity
+ * @param {Character} acted - Character on which the activity was triggered
+ * @param {AssetItemGroup} targetGroup - The group targetted by the activity
+ * @param {ItemActivity} ItemActivity - The activity performed, with its optional item used
+ * @param {boolean} sendMessage - Whether to send a message to the chat or not
+ */
+declare function ActivityRun(actor: Character, acted: Character, targetGroup: AssetItemGroup, ItemActivity: ItemActivity, sendMessage?: boolean): void;
+/**
+ * Checks if a used asset should trigger an activity/arousal progress on the target character
+ * @param {Character} Source - The character who used the item
+ * @param {Character} Target - The character on which the item was used
+ * @param {Asset} Asset - Asset used
+ * @return {void} - Nothing
+ */
+declare function ActivityArousalItem(Source: Character, Target: Character, Asset: Asset): void;
+/**
+ * Checks if the character is wearing an item tagged with the fetish type name and returns the love factor for it
+ * @param {Character} C - The character to validate
+ * @param {FetishName} Type - The fetish type name
+ * @return {number} - From -2 (hate it) to 2 (adore it) based on the player preferences
+ */
+declare function ActivityFetishItemFactor(C: Character, Type: FetishName): number;
+/**
+ * Loops in all fetishes for a character and calculates the total fetish factor
+ * @param {Character} C - The character to validate
+ * @return {number} - The negative/positive number will have negative/positive impact on arousal
+ */
+declare function ActivityFetishFactor(C: Character): number;
+/** @type {null | string[][]} */
+declare var ActivityDictionary: null | string[][];
+declare var ActivityOrgasmGameButtonX: number;
+declare var ActivityOrgasmGameButtonY: number;
+declare var ActivityOrgasmGameProgress: number;
+declare var ActivityOrgasmGameDifficulty: number;
+declare var ActivityOrgasmGameResistCount: number;
+declare var ActivityOrgasmGameTimer: number;
+declare var ActivityOrgasmResistLabel: string;
+declare var ActivityOrgasmRuined: boolean;

package/bc/Scripts/AfkTimer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Resets the timer for AFK count
+ * @returns {void} - Nothing
+ */
+declare function AfkTimerReset(): void;
+/**
+ * Increments the AFK Timer by 1. Is called from the browser's timer handler method.
+ * @see {@link AfkTimerStart} and {@link AfkTimerStop} for the registering and unregistering of this function.
+ * @returns {void} - Nothing
+ */
+declare function AfkTimerIncrement(): void;
+/**
+ * Registers the AfkTimerReset method for every event that is listed in AfkTimerEventsList and starts the timer count.
+ * @returns {void} - Nothing
+ */
+declare function AfkTimerStart(): void;
+/**
+ * Unregisters the AfkTimerReset method from all events listed in AfkTimerEventsList and stops the timer count
+ * @returns {void} - Nothing
+ */
+declare function AfkTimerStop(): void;
+/**
+ * Enables or disables the afk timer. Is called, when the player changes her settings in the preferences dialog
+ * @param {boolean} Enabled - Determines, whether the afk timer will be enabled (true) or disabled (false).
+ * @returns {void} - Nothing
+ */
+declare function AfkTimerSetEnabled(Enabled: boolean): void;
+/**
+ * Sets the players's emote to the Afk symbol, when the timer runs out and saves the current Emoticon, if there is any
+ * @returns {void} - Nothing
+ */
+declare function AfkTimerSetIsAfk(): void;
+declare var AfkTimerIncrementMs: number;
+declare var AfkTimerTimout: number;
+declare var AfkTimerIdle: number;
+declare var AfkTimerIsSet: boolean;
+/** @type {null | boolean} */
+declare var AfkTimerIsEnabled: null | boolean;
+declare var AfkTimerEventsList: string[];
+/** @type {null | ReturnType<typeof setInterval>} */
+declare var AfkTimerID: null | ReturnType<typeof setInterval>;
+/** @type {null | ExpressionNameMap["Emoticon"]} */
+declare var AfkTimerOldEmoticon: null | ExpressionNameMap["Emoticon"];

package/bc/Scripts/Animation.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Gets the dynamic data storage name for a given item on a given character.
+ * @param {Character} C - Character wearing the animated object
+ * @param {AnimationDataTypes} Type - Type of data to query
+ * @param {Asset} [Asset] - The animated object
+ * @returns {string} - Contains the name of the persistent data key.
+ */
+declare function AnimationGetDynamicDataName(C: Character, Type: AnimationDataTypes, Asset?: Asset): string;
+/**
+ * Gets the persistent data  for a given item on a given character. This method should not be called explicitly, use the Data builder passed to the dynamic drawing functions.
+ * @param {Character} C - Character wearing the animated object
+ * @param {Asset} Asset - The animated object
+ * @returns {any} - Contains the persistent data of the animated object, returns a new empty object if it was never initialized previously.
+ */
+declare function AnimationPersistentDataGet(C: Character, Asset: Asset): any;
+/**
+ * Sets the maximum animation refresh rate for a given character.
+ * @param {Character} C - Character wearing the dynamic object
+ * @param {number} RequestedRate - The maximum refresh rate to request in ms
+ * @returns {void} - Nothing
+ */
+declare function AnimationRequestRefreshRate(C: Character, RequestedRate: number): void;
+/**
+ * Marks a given character to be redrawn on the next animation refresh.
+ * @param {Character} C - Character wearing the dynamic object
+ * @returns {void} - Nothing
+ */
+declare function AnimationRequestDraw(C: Character): void;
+/**
+ * Gets the group object for a given character. This method should not be called explicitly, use the Data builder passed to the dynamic drawing functions.
+ * @param {Character} C - Character wearing the animated object
+ * @param {string} Name - Name of the animated object
+ * @returns {{ Subscriptions: string[] }} - Contains the persistent group data, returns a new empty object if it was never initialized previously.
+ */
+declare function AnimationGroupGet(C: Character, Name: string): {
+    Subscriptions: string[];
+};
+/**
+ * Marks a given asset as part of a shared data group.
+ * @param {Character} C - Character wearing the dynamic object
+ * @param {Asset} Asset - The animated object
+ * @param {string} Name - Name of the group to subscribe to.
+ * @returns {void} - Nothing
+ */
+declare function AnimationGroupSubscribe(C: Character, Asset: Asset, Name: string): void;
+/**
+ * Generates a temporary canvas used draw on for dynamic assets.
+ * Careful! The width of the canvas should never be higher than 500px.
+ * @param {Character} C - Character for which the temporary canvas is
+ * @param {Asset} A - Asset for which the canvas is
+ * @param {number} W - Width of the canvas (can be changed later)
+ * @param {number} H - Height of the canvas (can be changed later)
+ * @returns {HTMLCanvasElement} - The temporary canvas to use
+ */
+declare function AnimationGenerateTempCanvas(C: Character, A: Asset, W: number, H: number): HTMLCanvasElement;
+/**
+ * Purges all dynamic asset data corresponding to a given character.
+ * @param {Character} C - The character to delete the animation data of
+ * @param {boolean} IncludeAll - TRUE if we should delete every animation data for the given character.
+ * @returns {void} - Nothing
+ */
+declare function AnimationPurge(C: Character, IncludeAll: boolean): void;
+/**
+ * Where animation data is stored. Animation data is only managed client side, nothing should be synced.
+ * @constant
+ * @type {Record<string, any>} - The animation data object.
+ */
+declare var AnimationPersistentStorage: Record<string, any>;
+/**
+ * Types of dynamic data that can be stored.
+ * @type {{ AssetGroup: "AssetGroup", Base: "", Canvas: "DynamicPlayerCanvas", PersistentData: "PersistentData", Rebuild: "Rebuild", RefreshTime: "RefreshTime", RefreshRate: "RefreshRate" }}
+ */
+declare var AnimationDataTypes: {
+    AssetGroup: "AssetGroup";
+    Base: "";
+    Canvas: "DynamicPlayerCanvas";
+    PersistentData: "PersistentData";
+    Rebuild: "Rebuild";
+    RefreshTime: "RefreshTime";
+    RefreshRate: "RefreshRate";
+};