bc-stubs 96.0.0

package/bc/Scripts/PortalLink.d.ts

@@ -0,0 +1,159 @@
+/** @type {ExtendedItemCallbacks.Init} */
+declare function PortalLinkRecieverInit(C: Character, Item: Item, Refresh: boolean): boolean;
+/** @type {ExtendedItemCallbacks.Load} */
+declare function PortalLinkRecieverLoad(): void;
+/** @type {ExtendedItemCallbacks.Draw} */
+declare function PortalLinkRecieverDraw(): void;
+/** @type {ExtendedItemCallbacks.Click} */
+declare function PortalLinkRecieverClick(): void;
+declare function PortalLinkRecieverExit(): void;
+/** @type {ExtendedItemCallbacks.Init} */
+declare function PortalLinkTransmitterInit(C: Character, Item: Item, Refresh: boolean): boolean;
+/** @type {ExtendedItemCallbacks.Load} */
+declare function PortalLinkTransmitterLoad(): void;
+/** @type {ExtendedItemCallbacks.Draw} */
+declare function PortalLinkTransmitterDraw(): void;
+/** @type {ExtendedItemCallbacks.Click} */
+declare function PortalLinkTransmitterClick(): void;
+/** @type {ExtendedItemCallbacks.Exit} */
+declare function PortalLinkTransmitterExit(): void;
+/**
+ * Draw the sync code UI depending on the mode.
+ * Reciever has Random and Copy to clipboard buttons, transmitter has
+ * Copy from clipboard and link status label.
+ *
+ * @param {boolean} reciever - Whether it's in reciever or transmitter mode
+ */
+declare function PortalLinkSyncCodeInputDraw(reciever: boolean): void;
+declare function PortalLinkSyncCodeInputClick(reciever: any): void;
+/**
+ * Input listener for changes to the sync code field
+ * @param {Character} C - The character wearing the item
+ * @param {Item} Item - The item being changed
+ * @param {boolean} reciever - Whether the called is a reciever or not
+ */
+declare function PortalLinkCodeChanged(C: Character, Item: Item, reciever: boolean): void;
+/**
+ * Get the transmitter sync code from a character
+ * @param {Character} C
+ */
+declare function PortalLinkGetTransmitterCode(C: Character): string;
+/**
+ * Get the list of all items that match a given sync code in the chatroom.
+ * @param {string} linkCode
+ * @returns {[Character, Item][]}
+ */
+declare function PortalLinkGetItemsWithCode(linkCode: string): [Character, Item][];
+/**
+ * Checks the transmitter's link status with its reciever.
+ * @param {Character} C - The character wearing the transmitter
+ * @param {boolean} newLink - Whether it's a new link being setup
+ */
+declare function PortalLinkTransmitterCheckLinkStatus(C: Character, newLink?: boolean): void;
+/**
+ * Gathers the list of available functions for a given asset.
+ * @param {Item} item
+ */
+declare function PortalLinkGetFunctions(item: Item): PortalLinkFunction[];
+/**
+ * Broadcast an hidden ProcessLink message to the chatroom
+ * @param {Character} target
+ * @param {Item} item
+ * @param {PortalLinkFunction} func
+ */
+declare function PortalLinkPublishMessage(target: Character, item: Item, func: PortalLinkFunction): void;
+/**
+ *
+ * @param {Character} sender
+ * @param {Item} item
+ */
+declare function PortalLinkCycleChastityModule(sender: Character, item: Item): void;
+/**
+ * The handler for processing the hidden PortalLink messages
+ * @param {Character} sender
+ * @param {IChatRoomMessage} data
+ */
+declare function PortalLinkProcessMessage(sender: Character, data: IChatRoomMessage): void;
+/**
+ * This file contains everything needed to add remote-style functions
+ * (a.k.a PortalLink compatibility) to an asset, both as a transmitter
+ * or a reciever item.
+ * For transmitters, you'll need to call the following {@link ExtendedItemCallbacks}
+ * callbacks:
+ * - {@link PortalLinkTransmitterInit}
+ * - {@link PortalLinkTransmitterLoad}
+ * - {@link PortalLinkTransmitterDraw}
+ * - {@link PortalLinkTransmitterExit}
+ *
+ * Recievers have their own set of matching functions:
+ * - {@link PortalLinkRecieverInit}
+ * - {@link PortalLinkRecieverLoad}
+ * - {@link PortalLinkRecieverDraw}
+ * - {@link PortalLinkRecieverExit}
+ *
+ * That should be enough to give your asset the basic "sync code" UI handling,
+ * a reciever will only be detected if it supports at least one function (see below).
+ *
+ * ## PortalLink functions
+ *
+ * They are handled by a set of attributes, which the reciever needs to add to its
+ * {@link AssetDefinition.Attribute} to declare it supports it. The transmitter will
+ * detect those (via {@link PortalLinkGetFunctions}) and use them in its UI.
+ *
+ * Currently supported PortalLink functions (and their required attributes) are:
+ *
+ * - `PortalLinkFunctionLock` and `PortalLinkFunctionUnlock`:
+ * Those two functions are supported when the `PortalLinkLockable` attribute exists
+ * on the reciever, and enable remote-locking.
+ *
+ * - `PortalLinkFunctionCycleChastity`:
+ * Enabled when the `PortalLinkChastity${string}` attribute exists the reciever, and
+ * allows the reciever's chastity state to be cycled;
+ *
+ * @note Right now only modular items are supported, and `${string}` in the attribute
+ * is used to look up the module name ({@link ModularItemModuleConfig.Name}) to cycle
+ * on the reciever.
+ *
+ * - `PortalLinkFunctionActivity${ActivityName}`;
+ * Enabled when the `PortalLinkActivity${ActivityName}` attribute exists on the reciever,
+ * and allows the transmitter to perform the activity named `${ActivityName}` through
+ * the transmitter. By default activities will happen on the group the reciever is in,
+ * but you can use the `PortalLinkTarget${AssetGroupItemName}` to change the target.
+ *
+ * Since attributes are customizable at both the asset and option/module-level, you can
+ * get pretty involved combinations working. See the PortalPanties and how cycling the
+ * chastity changes the activity target for a good example.
+ *
+ * ## Low-level details
+ *
+ * The low-level protocol "exchange" itself is done in the following way:
+ * function discovery is made with {@link PortalLinkGetFunctions}, {@link PortalLinkPublishMessage} is
+ * called when a button is clicked from the transmitter UI on the senders' side, and its counterpart
+ * {@link PortalLinkProcessMessage} is called when a PortalLink message is recieved on the target's side.
+ * If you want to add more functions, those are the main three you should look at.
+ */
+/** Max length of sync codes */
+declare const PortalLinkCodeLength: 8;
+/** Regex string for what consitutes a valid sync code */
+declare const PortalLinkCodeText: string;
+/** Same thing but in regex form for quick .test and .match */
+declare const PortalLinkCodeRegex: RegExp;
+/** The DOM ID for the sync code field */
+declare const PortalLinkCodeInputID: "PortalLinkCode";
+/**
+ * Parameters for the button grid
+ * @type {CommonGenerateGridParameters}
+ */
+declare const PortalLinkFunctionGrid: CommonGenerateGridParameters;
+/** @type {PortalLinkStatus} */
+declare let PortalLinkTransmitterStatus: PortalLinkStatus;
+/** @type {number | null} */
+declare let PortalLinkTransmitterLastLinkCheck: number | null;
+/** @type {RectTuple} */
+declare const PortalLinkRandomCodeButton: RectTuple;
+/** @type {RectTuple} */
+declare const PortalLinkCopyCodeButton: RectTuple;
+/** @type {RectTuple} */
+declare const PortalLinkPasteCodeButton: RectTuple;
+/** @type {Record<PortalLinkStatus, string>} */
+declare const PortalLinkStatusColors: Record<PortalLinkStatus, string>;

package/bc/Scripts/Property.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Construct an item-specific ID for a properties input element (_e.g._ an opacity slider).
+ * @param {string} Name - The name of the input element
+ * @param {Item} Item - The item for whom the ID should be constructed; defaults to {@link DialogFocusItem}
+ * @returns {string} - The ID of the property
+ */
+declare function PropertyGetID(Name: string, Item?: Item): string;
+/**
+ * Load function for items with opacity sliders. Constructs the opacity slider.
+ * @param {null | ExtendedItemData<any>} Data - The items extended item data
+ * @param {null | (() => void)} OriginalFunction - The function that is normally called when an archetypical item reaches this point (if any).
+ * @param {ThumbIcon} thumbIcon The icon to use for the range input's "thumb" (handle).
+ * @returns {HTMLInputElement} - The new or pre-existing range input element of the opacity slider
+ */
+declare function PropertyOpacityLoad(Data?: null | ExtendedItemData<any>, OriginalFunction?: null | (() => void), thumbIcon?: ThumbIcon): HTMLInputElement;
+/**
+ * Draw function for items with opacity sliders. Draws the opacity slider and further opacity-related information.
+ * @param {null | ExtendedItemData<any>} Data - The items extended item data
+ * @param {null | (() => void)} OriginalFunction - The function that is normally called when an archetypical item reaches this point (if any).
+ * @param {number} XOffset - An offset for all text and slider X coordinates
+ * @param {number} YOffset - An offset for all text and slider Y coordinates
+ * @param {string} LabelKeyword - The keyword of the opacity label
+ * @returns {void} Nothing
+ */
+declare function PropertyOpacityDraw(Data?: null | ExtendedItemData<any>, OriginalFunction?: null | (() => void), XOffset?: number, YOffset?: number, LabelKeyword?: string): void;
+/**
+ * Exit function for items with opacity sliders. Updates the items opacity, deletes the slider and (optionally) refreshes the character and item.
+ * @param {null | ExtendedItemData<any>} Data - The items extended item data
+ * @param {null | (() => void)} OriginalFunction - The function that is normally called when an archetypical item reaches this point (if any).
+ * @param {boolean} Refresh - Whether character parameters and the respective item should be refreshed or not
+ * @returns {boolean} Whether the opacity was updated or not
+ */
+declare function PropertyOpacityExit(Data?: null | ExtendedItemData<any>, OriginalFunction?: null | (() => void), Refresh?: boolean): boolean;
+/**
+ * Validation function for items with opacity sliders.
+ * @type {ExtendedItemScriptHookCallbacks.Validate<ExtendedItemData<any>, any>}
+ */
+declare function PropertyOpacityValidate(Data: ExtendedItemData<any>, OriginalFunction: (C: Character, item: Item, newOption: any, previousOption: any, permitExisting?: boolean) => string, C: Character, Item: Item, Option: any, CurrentOption: any): string;
+/**
+ * Helper fuction for publishing shock-related actions.
+ * @param {Character} C - The shocked character; defaults to the {@link CharacterGetCurrent} output
+ * @param {Item} Item - The shocking item; defaults to {@link DialogFocusItem}
+ * @param {boolean} Automatic - Whether the shock was triggered automatically or otherwise manually
+ */
+declare function PropertyShockPublishAction(C?: Character, Item?: Item, Automatic?: boolean): void;
+/**
+ * Check if a given message warants automatic punishment given the provided sensitivety level
+ * @param {0 | 1 | 2 | 3} Sensitivity - The auto-punishment sensitivety
+ * @param {string} msg - The to-be checked message
+ * @returns {boolean} Whether the passed message should trigger automatic speech-based punishment
+ */
+declare function PropertyAutoPunishParseMessage(Sensitivity: 0 | 1 | 2 | 3, msg: string): boolean;
+/**
+ * Check whether the last uttered message should trigger automatic punishment from the provided item
+ * @param {Item} Item - The item in question
+ * @param {number | null} LastMessageLen - The length of {@link ChatRoomLastMessage} prior to the last message (if applicable)
+ * @returns {boolean} Whether the last message should trigger automatic speech-based punishment
+ */
+declare function PropertyAutoPunishDetectSpeech(Item: Item, LastMessageLen?: number | null): boolean;
+/**
+ * Merge all passed item properties into the passed output, merging (and shallow copying) arrays if necessary.
+ * @param {ItemProperties} output - The to be updated properties
+ * @param {readonly ItemProperties[]} args - The additional item properties to be merged into the output
+ * @returns {ItemProperties} - The passed output modified inplace
+ */
+declare function PropertyUnion(output: ItemProperties, ...args: readonly ItemProperties[]): ItemProperties;
+/**
+ * Remove all passed item properties from the passed output, removing (and shallow copying) array entries if necessary.
+ * @param {ItemProperties} output - The to-be updated properties
+ * @param {readonly ItemProperties[]} args - The additional item properties to be removed from the output
+ * @returns {ItemProperties} - The passed output modified inplace
+ */
+declare function PropertyDifference(output: ItemProperties, ...args: readonly ItemProperties[]): ItemProperties;
+/**
+ * Property.js
+ * -----------
+ * A module with common helper functions for the handling of specific {@link ItemProperties} properties.
+ * Note that more generic extended item functions should be confined to `ExtendedItem.js`.
+ */
+/**
+ * A Map that maps input element IDs to their original value is defined in, _.e.g_, {@link PropertyOpacityLoad}.
+ * Used as fallback in case an invalid opacity value is encountered when exiting.
+ * @type {Map<string, any>}
+ */
+declare const PropertyOriginalValue: Map<string, any>;
+declare function PropertyOpacityChange(C: any, Item: any, Opacity: any): void;
+/**
+ * A set of group names whose auto-punishment has successfully been handled by {@link PropertyAutoPunishDetectSpeech}.
+ * If a group name is absent from the set then it's eligible for action-based punishment triggers.
+ * The initial set is populated by {@link AssetLoadAll} after all asset groups are defined.
+ * @type {Set<AssetGroupName>}
+ */
+declare let PropertyAutoPunishHandled: Set<AssetGroupName>;
+/**
+ * A list of keywords that can trigger automatic punishment when included in `/me`- or `*`-based messages
+ * @type {readonly string[]}
+ */
+declare const PropertyAutoPunishKeywords: readonly string[];

package/bc/Scripts/Reputation.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Alters a given reputation value for the player
+ * @param {ReputationType} RepType - The name/type of the reputation to alter
+ * @param {number} RepValue - Reputation to add/subtract to the current reputation value.
+ * @param {boolean} [Push=true] - Pushes the reputation to the server if TRUE
+ * @returns {void} - Nothing
+ */
+declare function ReputationChange(RepType: ReputationType, RepValue: number, Push?: boolean): void;
+/**
+ * Loads the reputation data from the server
+ * @param {readonly Reputation[]} NewRep - The array of reputation-value pairs to load for the current player
+ * @returns {void} - Nothing
+ */
+declare function ReputationLoad(NewRep: readonly Reputation[]): void;
+/**
+ * Returns a specific reputation value for the player
+ * @param {ReputationType} RepType - Type/name of the reputation to get the value of.
+ * @returns {number} - Returns the value of the reputation. It can range from 100 to -100, and it defaults to 0 if the player never earned this type of reputation before.
+ */
+declare function ReputationGet(RepType: ReputationType): number;
+/**
+ * Returns a specific reputation value for a given character
+ * @param {Character} C - Character to get the reputation for.
+ * @param {ReputationType} RepType - Type/name of the reputation to get the value of.
+ * @returns {number} - Returns the value of the reputation. It can range from 100 to -100, and it defaults to 0 if the given character never earned this type of reputation before.
+ */
+declare function ReputationCharacterGet(C: Character, RepType: ReputationType): number;
+/**
+ * Alter the reputation progress by a factor. The higher the rep, the slower it gets, a reputation is easier to break than to build. Takes the cheater version factor into account.
+ * @param {ReputationType} RepType - Type/name of the reputation
+ * @param {number|string} Value - Value of the reputation change before the factor is applied
+ * @return {void} - Nothing
+ */
+declare function ReputationProgress(RepType: ReputationType, Value: number | string): void;
+/** @type {ReputationType[]} */
+declare var ReputationValidReputations: ReputationType[];

package/bc/Scripts/Server.d.ts

@@ -0,0 +1,239 @@
+/** Loads the server by attaching the socket events and their respective callbacks */
+declare function ServerInit(): void;
+/**
+ * Sets the connection status of the server and updates the login page message
+ * @param {boolean} connected - whether or not the websocket connection to the server has been established successfully
+ * @param {string} [errorMessage] - the error message to display if not connected
+ */
+declare function ServerSetConnected(connected: boolean, errorMessage?: string): void;
+/**
+ * Callback when receiving a "connect" event on the socket - this will be called on initial connection and on
+ * successful reconnects.
+ */
+declare function ServerConnect(): void;
+/**
+ * Callback when receiving a "reconnecting" event on the socket - this is called when socket.io initiates a retry after
+ * a failed connection attempt.
+ */
+declare function ServerReconnecting(): void;
+/**
+ * Callback used to parse received information related to the server
+ * @param {{OnlinePlayers: number, Time: number}} data - Data object containing the server information
+ * @returns {void} - Nothing
+ */
+declare function ServerInfo(data: {
+    OnlinePlayers: number;
+    Time: number;
+}): void;
+/**
+ * Callback used when we are disconnected from the server, try to enter the reconnection mode (relog screen) if the
+ * user was logged in
+ * @param {*} data - Error to log
+ * @param {boolean} [close=false] - close the transport
+ * @returns {void} - Nothing
+ */
+declare function ServerDisconnect(data: any, close?: boolean): void;
+/**
+ * Returns whether the player is currently in a chatroom or viewing a subscreen while in a chatroom
+ * @returns {boolean} - True if in a chatroom
+ */
+declare function ServerPlayerIsInChatRoom(): boolean;
+/** Sends a message with the given data to the server via socket.emit */
+declare function ServerSend(Message: any, Data: any): void;
+/**
+ * Syncs Money, owner name and lover name with the server
+ * @returns {void} - Nothing
+ */
+declare function ServerPlayerSync(): void;
+/**
+ * Syncs the full player inventory to the server.
+ * @returns {void} - Nothing
+ */
+declare function ServerPlayerInventorySync(): void;
+/**
+ * Syncs player's favorite, blocked, limited and hidden items to the server
+ * @returns {void} - Nothing
+ */
+declare function ServerPlayerBlockItemsSync(): void;
+/**
+ * Syncs the full player log array to the server.
+ * @returns {void} - Nothing
+ */
+declare function ServerPlayerLogSync(): void;
+/**
+ * Syncs the full player reputation array to the server.
+ * @returns {void} - Nothing
+ */
+declare function ServerPlayerReputationSync(): void;
+/**
+ * Syncs the full player skill array to the server.
+ * @returns {void} - Nothing
+ */
+declare function ServerPlayerSkillSync(): void;
+/**
+ * Syncs player's relations and related info to the server.
+ * @returns {void} - Nothing
+ */
+declare function ServerPlayerRelationsSync(): void;
+/**
+ * Prepares an appearance bundle so we can push it to the server. It minimizes it by keeping only the necessary
+ * information. (Asset name, group name, color, properties and difficulty)
+ * @param {readonly Item[]} Appearance - The appearance array to bundle
+ * @returns {AppearanceBundle} - The appearance bundle created from the given appearance array
+ */
+declare function ServerAppearanceBundle(Appearance: readonly Item[]): AppearanceBundle;
+/**
+ * Loads the appearance assets from a server bundle that only contains the main info (no asset) and validates their
+ * properties to prevent griefing and respecting permissions in multiplayer
+ * @param {Character} C - Character for which to load the appearance
+ * @param {IAssetFamily} AssetFamily - Family of assets used for the appearance array
+ * @param {AppearanceBundle} Bundle - Bundled appearance
+ * @param {number} [SourceMemberNumber] - Member number of the user who triggered the change
+ * @param {boolean} [AppearanceFull=false] - Whether or not the appearance should be assigned to an NPC's AppearanceFull
+ * property
+ * @returns {boolean} - Whether or not the appearance bundle update contained invalid items
+ */
+declare function ServerAppearanceLoadFromBundle(C: Character, AssetFamily: IAssetFamily, Bundle: AppearanceBundle, SourceMemberNumber?: number, AppearanceFull?: boolean): boolean;
+/**
+ * Builds a diff map for comparing changes to a character's appearance, keyed by asset group name
+ * @param {IAssetFamily} assetFamily - The asset family of the appearance
+ * @param {readonly Item[]} appearance - The current appearance to compare against
+ * @param {AppearanceBundle} bundle - The new appearance bundle
+ * @returns {AppearanceDiffMap} - An appearance diff map representing the changes that have been made to the character's
+ * appearance
+ */
+declare function ServerBuildAppearanceDiff(assetFamily: IAssetFamily, appearance: readonly Item[], bundle: AppearanceBundle): AppearanceDiffMap;
+/**
+ * Maps a bundled appearance item, as stored on the server and used for appearance update messages, into a full
+ * appearance item, as used by the game client
+ * @param {IAssetFamily} assetFamily - The asset family of the appearance item
+ * @param {ItemBundle} item - The bundled appearance item
+ * @returns {Item} - A full appearance item representation of the provided bundled appearance item
+ */
+declare function ServerBundledItemToAppearanceItem(assetFamily: IAssetFamily, item: ItemBundle): Item;
+/**
+ * Parses an item color, based on the allowed colorable layers on an asset, and the asset's color schema
+ * @param {Asset} asset - The asset on which the color is set
+ * @param {string | readonly string[]} color - The color value to parse
+ * @param {readonly string[]} schema - The color schema to validate against
+ * @returns {string|string[]} - A parsed valid item color
+ */
+declare function ServerParseColor(asset: Asset, color: string | readonly string[], schema: readonly string[]): string | string[];
+/**
+ * Populates an appearance diff map with any required items, to ensure that all asset groups are present that need to
+ * be.
+ * @param {IAssetFamily} assetFamily - The asset family for the appearance
+ * @param {AppearanceDiffMap} diffMap - The appearance diff map to populate
+ * @returns {void} - Nothing
+ */
+declare function ServerAddRequiredAppearance(assetFamily: IAssetFamily, diffMap: AppearanceDiffMap): void;
+/**
+ * Validates and returns a color against a color schema
+ * @param {string} Color - The color to validate
+ * @param {readonly string[]} Schema - The color schema to validate against (a list of accepted Color values)
+ * @returns {string} - The color if it is a valid hex color string or part of the color schema, or the default color
+ *     from the color schema otherwise
+ */
+declare function ServerValidateColorAgainstSchema(Color: string, Schema: readonly string[]): string;
+/**
+ * Syncs the player appearance with the server
+ * @returns {void} - Nothing
+ */
+declare function ServerPlayerAppearanceSync(): void;
+/**
+ * Syncs all the private room characters with the server
+ * @returns {void} - Nothing
+ */
+declare function ServerPrivateCharacterSync(): void;
+/**
+ * Callback used to parse received information related to a query made by the player such as viewing their online
+ * friends or current email status
+ * @param {object} data - Data object containing the query data
+ * @returns {void} - Nothing
+ */
+declare function ServerAccountQueryResult(data: object): void;
+/**
+ * Callback used to parse received information related to a beep from another account
+ * @param {object} data - Data object containing the beep object which contain at the very least a name and a member
+ *     number
+ * @returns {void} - Nothing
+ */
+declare function ServerAccountBeep(data: object): void;
+/** Draws the last beep sent by the server if the timer is still valid, used during the drawing process */
+declare function ServerDrawBeep(): void;
+/** Handles a click on the beep rectangle if mail is included */
+declare function ServerClickBeep(): void;
+/** Opens the friendlist from any screen */
+declare function ServerOpenFriendList(): void;
+/**
+ * Callback used to parse received information related to the player ownership data
+ * @param {object} data - Data object containing the Owner name and Ownership object
+ * @returns {void} - Nothing
+ */
+declare function ServerAccountOwnership(data: object): void;
+/**
+ * Callback used to parse received information related to the player lovership data
+ * @param {object} data - Data object containing the Lovership array
+ * @returns {void} - Nothing
+ */
+declare function ServerAccountLovership(data: object): void;
+/**
+ * Compares the source account and target account to check if we allow using an item
+ *
+ * **This function MUST match server's identical function!**
+ * @param {Character} Source
+ * @param {Character} Target
+ * @returns {boolean}
+ */
+declare function ServerChatRoomGetAllowItem(Source: Character, Target: Character): boolean;
+/** @type {SocketIO.Socket} */
+declare var ServerSocket: SocketIO.Socket;
+declare var ServerURL: string;
+/** @type { { Message: string; Timer: number; ChatRoomName?: string | null; IsMail?: boolean; } } */
+declare var ServerBeep: {
+    Message: string;
+    Timer: number;
+    ChatRoomName?: string | null;
+    IsMail?: boolean;
+};
+declare var ServerIsConnected: boolean;
+declare var ServerReconnectCount: number;
+declare var ServerAccountEmailRegex: RegExp;
+declare var ServerAccountNameRegex: RegExp;
+declare var ServerAccountPasswordRegex: RegExp;
+declare var ServerAccountResetNumberRegex: RegExp;
+declare var ServerCharacterNameRegex: RegExp;
+declare var ServerCharacterNicknameRegex: RegExp;
+declare const ServerScriptMessage: string;
+declare const ServerScriptWarningStyle: string;
+/** @readonly */
+declare var ServerAccountUpdate: {
+    /**
+     * @private
+     * @type {Map<string, object>}
+     */
+    Queue: Map<string, object>;
+    /**
+     * @private
+     * @type {null | ReturnType<typeof setTimeout>}
+     */
+    Timeout: null | ReturnType<typeof setTimeout>;
+    /**
+     * @private
+     * @type {number}
+     */
+    Start: number;
+    /** Clears queue and sync with server  */
+    SyncToServer(): void;
+    /**
+     * Queues a data to be synced at a later time
+     * @param {object} Data
+     * @param {true} [Force] - force immediate sync to server
+     */
+    QueueData(Data: object, Force?: true): void;
+};
+/**
+ * A map containing appearance item diffs, keyed according to the item group. Used to compare and validate before/after
+ * for appearance items.
+ */
+type AppearanceDiffMap = Partial<Record<AssetGroupName, Item[]>>;

package/bc/Scripts/Skill.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Returns the data for a given skill from a character
+ *
+ * @param {Character} C - The character to get skills from.
+ * @param {SkillType} skillType The skill to get
+ * @returns {Skill | undefined}
+ */
+declare function SkillGet(C: Character, skillType: SkillType): Skill | undefined;
+/**
+ * When the player progresses in a skill. Also validates the values to make sure they are within the proper ranges once changed. (level 0-10, progress 0-100)
+ * @param {Character} C - The character to get skills from.
+ * @param {SkillType} SkillType - Name of the skill to set the value for
+ * @param {number} SkillLevel - Level to set for the given skill
+ * @param {number} Progress - Progress to set for the given skill
+ * @param {boolean} [Push=true] - Pushes the skills to the server if TRUE
+ * @returns {void} - Nothing
+ */
+declare function SkillChange(C: Character, SkillType: SkillType, SkillLevel: number, Progress: number, Push?: boolean): void;
+/**
+ * Loads the skill data from the server on login
+ * @param {readonly Skill[]} NewSkill - The player skills array sent by the server
+ * @returns {void} - Nothing
+ */
+declare function SkillLoad(NewSkill: readonly Skill[]): void;
+/**
+ * Get a specific skill modifier from a character
+ * @param {Character} C
+ * @param {SkillType} SkillType
+ */
+declare function SkillGetModifier(C: Character, SkillType: SkillType): number;
+/**
+ * Get the timeout value on a skill modifier
+ *
+ * @param {Character} C - The character to get skills from
+ * @param {SkillType} SkillType
+ * @returns At which (absolute) time will the modifier expire
+ */
+declare function SkillGetModifierDuration(C: Character, SkillType: SkillType): number;
+/**
+ * Set a specific skill modifier to apply for a given duration on the target character.
+ * @param {Character} C - The character to change the modifier on
+ * @param {SkillType} SkillType - The skill the modifier applies to
+ * @param {number} Value - The new value of the modifier
+ * @param {number} Duration - The length of the modifier effect, in ms
+ * @param {boolean} [Push=true] - Pushes the skills to the server if TRUE
+ * @returns {boolean} true if the new value was valid, false if it got capped.
+ */
+declare function SkillSetModifier(C: Character, SkillType: SkillType, Value: number, Duration: number, Push?: boolean): boolean;
+/**
+ * Get a specific skill level from a character WITH the current modifier applied
+ * @param {Character} C - Character for which we want to query a skill
+ * @param {SkillType} SkillType - Name of the skill to get the value of
+ * @returns {number} - Current level for the given skill.
+ */
+declare function SkillGetLevel(C: Character, SkillType: SkillType): number;
+/**
+ * Get a specific skill level from a character WITHOUT the modifier applied
+ * @param {Character} C - Character for which we want to query a skill
+ * @param {SkillType} SkillType - Name of the skill to get the value of
+ * @returns {number} - Current real level for the given skill.
+ */
+declare function SkillGetLevelReal(C: Character, SkillType: SkillType): number;
+/**
+ * Get a specific skill progress from a character
+ * @param {Character} C - Character for which we want to query a skill
+ * @param {SkillType} SkillType - Name of the skill to get the progress of
+ * @returns {number} - Current progress for the given skill.
+ */
+declare function SkillGetProgress(C: Character, SkillType: SkillType): number;
+/**
+ * Add progress to a skill, the skill progresses slower for each level, takes into account cheaters version.
+ * @param {Character} C - The character to get skills from
+ * @param {SkillType} SkillType - Name of the skill to add progress to
+ * @param {number} Progress - Progress to be made before the ratios are applied
+ * @returns {void} - Nothing
+ */
+declare function SkillProgress(C: Character, SkillType: SkillType, Progress: number): void;
+/**
+ * Sets the ratio % of a skill that's going to be used by the player
+ * @param {Character} C - The character to get the skill from
+ * @param {SkillType} SkillType - Name of the skill to get the value of
+ * @param {number} Ratio - The ratio to set for a given skill (0 to 1)
+ * @param {boolean} [Push=true] - Pushes the skills to the server if TRUE
+ */
+declare function SkillSetRatio(C: Character, SkillType: SkillType, Ratio: number, Push?: boolean): void;
+/**
+ * Gets the ratio % of effectiveness of a skill for a character
+ * @param {Character} C - The character to get the skill from
+ * @param {SkillType} SkillType - Name of the skill to get the value of
+ * @returns {number} - The current active ratio for the given skill
+ */
+declare function SkillGetRatio(C: Character, SkillType: SkillType): number;
+/**
+ * Gets a skill level with the current ratio applied to it, if the current skill has a % modifier.
+ * @param {Character} C - The character to get the skill from
+ * @param {SkillType} SkillType - Name of the skill to get the value of
+ * @returns {number} - The skill level with the ratio % applied
+ */
+declare function SkillGetWithRatio(C: Character, SkillType: SkillType): number;
+declare var SkillModifier: number;
+declare var SkillModifierMax: number;
+declare var SkillModifierMin: number;
+declare var SkillLevelMaximum: number;
+declare var SkillLevelMinimum: number;
+declare var SkillProgressMax: number;
+/** @type {SkillType[]} */
+declare var SkillValidSkills: SkillType[];