bc-stubs 96.0.0

package/bc/Scripts/Validation.d.ts

@@ -0,0 +1,324 @@
+/**
+ * Creates the appearance update parameters used to validate an appearance diff, based on the provided target character
+ * and the source character's member number.
+ * @param {Character} C - The target character (to whom the appearance update is being applied)
+ * @param {number} sourceMemberNumber - The member number of the source player (the person that sent the update)
+ * @returns {AppearanceUpdateParameters} - Appearance update parameters used based on the relationship between the
+ * target and source characters
+ */
+declare function ValidationCreateDiffParams(C: Character, sourceMemberNumber: number): AppearanceUpdateParameters;
+/**
+ * Resolves an appearance diff based on the previous item, new item, and the appearance update parameters provided.
+ * Returns an {@link ItemDiffResolution} object containing the final appearance item and a valid flag indicating
+ * whether or not the new item had to be modified/rolled back.
+ * @param {AssetGroupName} groupName - The name of the group for the appearance diff
+ * @param {Item|null} previousItem - The previous item that the target character had equipped (or null if none)
+ * @param {Item|null} newItem - The new item to equip (may be identical to the previous item, or null if removing)
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @returns {ItemDiffResolution} - The diff resolution - a wrapper object containing the final item and a flag
+ * indicating whether or not the change was valid.
+ */
+declare function ValidationResolveAppearanceDiff(groupName: AssetGroupName, previousItem: Item | null, newItem: Item | null, params: AppearanceUpdateParameters): ItemDiffResolution;
+/**
+ * Check whether newArray is different from oldArray.
+ * @template T
+ * @param {T[]} oldArray
+ * @param {T[]} newArray
+ * @returns {boolean}
+ */
+declare function ValidationHasArrayPropertyBeenModified<T>(oldArray: T[], newArray: T[]): boolean;
+/**
+ * Resolves an appearance diff for the ItemScript group. This group has special rules and permissions which don't
+ * necessarily apply to or behave like other groups.
+ * @param {Item|null} previousItem - The previous item in the group
+ * @param {Item|null} newItem - The new item in the group
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @return {ItemDiffResolution} - The diff resolution
+ */
+declare function ValidationResolveScriptDiff(previousItem: Item | null, newItem: Item | null, { C, permissions, sourceMemberNumber }: AppearanceUpdateParameters): ItemDiffResolution;
+/**
+ * Resolves an appearance diff where an item is being added (i.e. there was no previous item in the asset group). Add
+ * diffs are handled as the composite of two operations: item addition, followed by property modification. First we
+ * check whether the base item can be added, and then we check that any added properties are permitted.
+ * @param {Item} newItem - The new item to equip
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @returns {ItemDiffResolution} - The diff resolution - a wrapper object containing the final item and a flag
+ * indicating whether or not the change was valid.
+ */
+declare function ValidationResolveAddDiff(newItem: Item, params: AppearanceUpdateParameters): ItemDiffResolution;
+/**
+ * Resolves an appearance diff where an item is being removed (i.e. there was previously an item in the asset group, but
+ * it is being removed)
+ * @param {Item} previousItem - The previous item to remove
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @param {boolean} [isSwap] - Whether or not the removal is part of an item swap operation. This will allow certain
+ * items which cannot normally be removed (e.g. items with `AllowNone: false`) to be removed
+ * @returns {ItemDiffResolution} - The diff resolution - a wrapper object containing the final item and a flag
+ * indicating whether or not the change was valid.
+ */
+declare function ValidationResolveRemoveDiff(previousItem: Item, params: AppearanceUpdateParameters, isSwap?: boolean): ItemDiffResolution;
+/**
+ * Resolves an appearance diff where an item is being swapped (i.e. there was an item previously in the asset group, but
+ * the new item uses a different asset to the previous item). Swap diffs are handled as the composite of three
+ * operations: item removal, item addition, and then property modification. First we check whether the previous item
+ * can be removed, then whether the new item can be added, and finally we check that any added properties are permitted.
+ * @param {Item} previousItem - The previous item to remove
+ * @param {Item} newItem - The new item to add
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @returns {ItemDiffResolution} - The diff resolution - a wrapper object containing the final item and a flag
+ * indicating whether or not the change was valid.
+ */
+declare function ValidationResolveSwapDiff(previousItem: Item, newItem: Item, params: AppearanceUpdateParameters): ItemDiffResolution;
+/**
+ * Resolves an appearance diff where an item is being modified (i.e. there was an item previously in the asset group,
+ * and the new item uses the same asset as the previous item). The function primarily validates modifications to locked
+ * items
+ * @param {Item} previousItem - The previous item to remove
+ * @param {Item} newItem - The new item to add
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @returns {ItemDiffResolution} - The diff resolution - a wrapper object containing the final item and a flag
+ * indicating whether or not the change was valid.
+ */
+declare function ValidationResolveModifyDiff(previousItem: Item, newItem: Item, params: AppearanceUpdateParameters): ItemDiffResolution;
+/**
+ * Resolves modifications to an item's lock properties and returns a boolean to indicate whether or not the
+ * modifications were valid.
+ * @param {Item} previousItem - The previous item to remove
+ * @param {Item} newItem - The new item to add
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @param {boolean} itemBlocked - Whether or not the item is blocked or limited for the source player
+ * @returns {boolean} - true if the lock modifications (if any) were valid, false otherwise
+ */
+declare function ValidationResolveLockModification(previousItem: Item, newItem: Item, params: AppearanceUpdateParameters, itemBlocked: boolean): boolean;
+/**
+ * Determines whether or not a lock was modified on an item from its previous and new property values
+ * @param {ItemProperties} previousProperty - The previous item property
+ * @param {ItemProperties} newProperty - The new item property
+ * @returns {boolean} - true if the item's lock was modified (added/removed/swapped/modified), false otherwise
+ */
+declare function ValidationLockWasModified(previousProperty: ItemProperties, newProperty: ItemProperties): boolean;
+/**
+ * Returns a commonly used warning message indicating that an invalid change to an item was made, along with the target
+ * and source characters' member numbers.
+ * @param {Item} item - The item being modified
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @returns {string} - The warning message
+ */
+declare function ValidationItemWarningMessage(item: Item, { C, sourceMemberNumber }: AppearanceUpdateParameters): string;
+/**
+ * Determines whether or not a lock can be modified based on the lock object and the provided appearance update
+ * parameters.
+ * @param {Item} lock - The lock object that is being checked, as returned by {@link InventoryGetLock}
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @param {boolean} [remove] - Whether the lock change is a removal
+ * @returns {boolean} - TRUE if the lock can be modified, FALSE otherwise
+ */
+declare function ValidationIsLockChangePermitted(lock: Item, { C, fromOwner, fromLover, fromFamily }: AppearanceUpdateParameters, remove?: boolean): boolean;
+/**
+ * Copies an item's lock-related properties from one Property object to another based on whether or not the source
+ * character has permissions to modify the lock. Rolls back any invalid changes to their previous values.
+ * @param {object} sourceProperty - The original Property object on the item
+ * @param {object} targetProperty - The Property object on the modified item
+ * @param {boolean} hasLockPermissions - Whether or not the source character of the appearance change has permission to
+ * modify the lock (as determined by {@link ValidationIsLockChangePermitted})
+ * @returns {boolean} - TRUE if the target Property object was modified as a result of copying (indicating that there
+ * were invalid changes to the lock), FALSE otherwise
+ */
+declare function ValidationRollbackInvalidLockProperties(sourceProperty: object, targetProperty: object, hasLockPermissions: boolean): boolean;
+/**
+ * Clones all lock properties from one Property object to another.
+ * @param {ItemProperties} sourceProperty - The property object to clone properties from
+ * @param {ItemProperties} targetProperty - The property object to clone properties to
+ * @returns {void} - Nothing
+ */
+declare function ValidationCloneLock(sourceProperty: ItemProperties, targetProperty: ItemProperties): void;
+/**
+ * Copies the value of a single property key from a source Property object to a target Property object.
+ * @param {ItemProperties} sourceProperty - The original Property object on the item
+ * @param {ItemProperties} targetProperty - The Property object on the modified item
+ * @param {string} key - The property key whose value to copy
+ * @returns {boolean} - TRUE if the target Property object was modified as a result of copying (indicating that there
+ * were invalid changes to the property), FALSE otherwise
+ */
+declare function ValidationCopyProperty(sourceProperty: ItemProperties, targetProperty: ItemProperties, key: string): boolean;
+/**
+ * Determines whether an item can be added to the target character, based on the provided appearance update parameters.
+ * Note that the item's properties are not taken into account at this stage - this merely checks whether the basic item
+ * can be added.
+ * @param {Item} newItem - The new item to add
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @returns {boolean} - TRUE if the new item can be equipped based on the appearance update parameters, FALSE otherwise
+ */
+declare function ValidationCanAddItem(newItem: Item, params: AppearanceUpdateParameters): boolean;
+/**
+ * Determines whether the character described by the `sourceMemberNumber` parameter is permitted to add a given asset to
+ * the target character `C`, based on the asset's group name, asset name and type (if applicable). This only checks
+ * against the target character's limited and blocked item lists, not their global item permissions.
+ * @param {Character} C - The target character
+ * @param {number} sourceMemberNumber - The member number of the source character
+ * @param {AssetGroupName} groupName - The name of the asset group for the intended item
+ * @param {string} assetName - The asset name of the intended item
+ * @param {string|null} [type] - The type of the intended item
+ * @returns {boolean} - TRUE if the character with the provided source member number is _not_ allowed to equip the
+ * described asset on the target character, FALSE otherwise.
+ */
+declare function ValidationIsItemBlockedOrLimited(C: Character, sourceMemberNumber: number, groupName: AssetGroupName, assetName: string, type?: string | null): boolean;
+/**
+ * Determines whether an item can be removed from the target character, based on the provided appearance update
+ * parameters.
+ * @param {Item} previousItem - The item to remove
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @param {boolean} isSwap - Whether or not the removal is part of a swap, which allows temporary removal of items with
+ * `AllowNone: false`.
+ * @returns {boolean} - TRUE if the item can be removed based on the appearance update parameters, FALSE otherwise
+ */
+declare function ValidationCanRemoveItem(previousItem: Item, params: AppearanceUpdateParameters, isSwap: boolean): boolean;
+/**
+ * Determines whether an item can be added or removed from the target character, based on the provided appearance update
+ * parameters.
+ * @param {Item} item - The item to add or remove
+ * @param {AppearanceUpdateParameters} params - The appearance update parameters that apply to the diff
+ * @return {boolean} - TRUE if the item can be added or removed based on the appearance update parameters, FALSE
+ * otherwise
+ */
+declare function ValidationCanAddOrRemoveItem(item: Item, { C, fromOwner, fromLover, fromFamily }: AppearanceUpdateParameters): boolean;
+/**
+ * Sanitizes the properties on an appearance item to ensure that no invalid properties are present. This removes invalid
+ * locks, strips invalid values, and ensures property values are within the constraints defined by an item.
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The appearance item to sanitize
+ * @returns {boolean} - TRUE if the item was modified as part of the sanitization process (indicating that invalid
+ * properties were present), FALSE otherwise
+ */
+declare function ValidationSanitizeProperties(C: Character, item: Item): boolean;
+/**
+ * Sanitizes the `Effect` array on an item's Property object, if present. This ensures that it is a valid array of
+ * strings, and that each item in the array is present in the asset's `AllowEffect` array.
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose `Effect` property should be sanitized
+ * @returns {boolean} - TRUE if the item's `Effect` property was modified as part of the sanitization process
+ * (indicating it was not a valid string array, or that invalid effects were present), FALSE otherwise
+ */
+declare function ValidationSanitizeEffects(C: Character, item: Item): boolean;
+/**
+ * Sanitizes an item's lock properties, if present. This ensures that any lock on the item is valid, and removes or
+ * corrects invalid properties.
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose lock properties should be sanitized
+ * @returns {boolean} - TRUE if the item's properties were modified as part of the sanitization process (indicating the
+ * lock was not valid), FALSE otherwise
+ */
+declare function ValidationSanitizeLock(C: Character, item: Item): boolean;
+/**
+ * Sanitizes an array on an item's Property object, if present. This ensures that it is a valid array of
+ * strings, and that each item in the array is present in the either the asset's corresponding property array or the
+ * "allow" array for that item.
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose property should be sanitized
+ * @param {keyof ItemProperties & keyof Asset} propertyName - The name of the property
+ * @param {keyof Asset} allowPropertyName - The name of the property corresponding to the list of allowed property
+ * values on the asset
+ * @returns {boolean} - TRUE if the item's property was modified as part of the sanitization process
+ * (indicating it was not a valid string array, or that invalid entries were present), FALSE otherwise
+ */
+declare function ValidationSanitizeAllowedPropertyArray(C: Character, item: Item, propertyName: keyof ItemProperties & keyof Asset, allowPropertyName: keyof Asset): boolean;
+/**
+ * Sanitizes the `SetPose` array on an item's Property object, if present. This ensures that it is a valid array of
+ * strings, and that each item in the array is present in the list of poses available in the game.
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose `SetPose` property should be sanitized
+ * @returns {boolean} - TRUE if the item's `SetPose` property was modified as part of the sanitization process
+ * (indicating it was not a valid string array, or that invalid entries were present), FALSE otherwise
+ */
+declare function ValidationSanitizeSetPose(C: Character, item: Item): boolean;
+/**
+ * Sanitizes a property on an object to ensure that it is a valid string array or null/undefined. If the property is not
+ * a valid array and is not null, it will be deleted from the object. If it is a valid array, any non-string entries
+ * will be removed.
+ * @param {ItemProperties} property - The object whose property should be sanitized
+ * @param {string} key - The key indicating which property on the object should be sanitized
+ * @returns {boolean} - TRUE if the object's property was modified as part of the sanitization process (indicating  that
+ * the property was not a valid array, or that it contained a non-string entry), FALSE otherwise
+ */
+declare function ValidationSanitizeStringArray(property: ItemProperties, key: string): boolean;
+/**
+ * Completely removes a lock from an item's Property object. This removes all lock-related properties, and the "Lock"
+ * effect from the property object.
+ * @param {ItemProperties} property - The Property object to remove the lock from
+ * @param {boolean} verbose - Whether or not to print console warnings when properties are deleted. Defaults to true.
+ * @returns {boolean} - TRUE if the Property object was modified as a result of the lock deletion (indicating that at
+ * least one lock-related property was present), FALSE otherwise
+ */
+declare function ValidationDeleteLock(property: ItemProperties, verbose?: boolean): boolean;
+/**
+ * Fixes any cyclic blocks in the provided appearance array. The given diff map is used to determine the order in which
+ * items should be rolled back or removed if block cycles are found (a block cycle being a series of items that block
+ * each other in a cyclic fashion).
+ * @param {Item[]} appearance - The appearance to sanitize
+ * @param {AppearanceDiffMap} diffMap - The appearance diff map which indicates the items that were changed as part of
+ * the appearance update that triggered this validation
+ * @returns {AppearanceValidationWrapper} - A wrapper containing the final appearance, with any block cycles removed,
+ * plus a valid flag indicating whether or not the appearance had to be modified.
+ */
+declare function ValidationResolveCyclicBlocks(appearance: Item[], diffMap: AppearanceDiffMap): AppearanceValidationWrapper;
+/**
+ * Finds any block cycles in the given appearance array. Block cycles are groups of items that block each other in a
+ * cyclic fashion. Block cycles are represented as an array of group names that comprise the cycle. For example:
+ * ["ItemArms", "ItemDevices", "ItemArms"]
+ * This indicates that the item in the ItemArms group blocks the item in the ItemDevices group, and vice versa. This
+ * function returns an array of such block cycles, or an empty array if none were found.
+ * Be advised that cyclic block checking is relatively expensive, so should only be run when needed - don't run it every
+ * frame!
+ * @param {Item[]} appearance - The appearance array to check
+ * @returns {string[][]} - A list of block cycles, each cycle being represented as an array of group names.
+ */
+declare function ValidationFindBlockCycles(appearance: Item[]): string[][];
+/**
+ * Finds the groups, from a provided list of groups, that are blocked by a given item.
+ * @param {Item} item - The item to check
+ * @param {readonly AssetGroupName[]} groupNames - A list of group names that should be used to filter the final block list
+ * @returns {AssetGroupName[]} - A subset of the provided group names representing the groups that are blocked by the given
+ * item.
+ */
+declare function ValidationGetBlockedGroups(item: Item, groupNames: readonly AssetGroupName[]): AssetGroupName[];
+/**
+ * Finds the groups from the provided appearance array that block a given item due to prerequisites. In this situation,
+ * an item is considered to be blocking if the target item can't be added with it, but can without it.
+ * @param {Item} item - The item to check
+ * @param {Item[]} appearance - The appearance array to check
+ * @returns {AssetGroupName[]} - A list of group names corresponding to items from the appearance array that block the given
+ * item due to prerequisites
+ */
+declare function ValidationGetPrerequisiteBlockingGroups(item: Item, appearance: Item[]): AssetGroupName[];
+/**
+ * Checks whether a character permits the given permission level to modify the given item property. For example,
+ * passing `Player` in as the character, `"Block"` in as the property and `ScriptPermissionLevel.FRIENDS` in as the
+ * permission level will check whether the player's friends are permitted to freely modify `"Block"` properties on the
+ * player's worn items without strict validation.
+ * @param {Character} character - The character to check
+ * @param {ScriptPermissionProperty} property - The name of the property to check
+ * @param {ScriptPermissionLevel} permissionLevel - The permission level to check
+ * @returns {boolean} TRUE if the character permits modifications to the provided property
+ */
+declare function ValidationHasScriptPermission(character: Character, property: ScriptPermissionProperty, permissionLevel: ScriptPermissionLevel): boolean;
+/**
+ * Checks whether a character permits any of the given permission levels to modify the given item property.
+ * @param {Character} character - The character to check
+ * @param {ScriptPermissionProperty} property - The name of the property to check
+ * @param {readonly ScriptPermissionLevel[]} permissionLevels - The permission levels to check
+ * @returns {boolean} TRUE if the character permits modifications to the provided property
+ */
+declare function ValidationHasSomeScriptPermission(character: Character, property: ScriptPermissionProperty, permissionLevels: readonly ScriptPermissionLevel[]): boolean;
+declare const ValidationCombinationNumberRegex: RegExp;
+declare const ValidationPasswordRegex: RegExp;
+declare const ValidationDefaultCombinationNumber: "0000";
+declare const ValidationDefaultPassword: "UNLOCK";
+declare const ValidationRemoveTimerToleranceMs: 5000;
+declare const ValidationNonModifiableLockProperties: string[];
+declare const ValidationRestrictedLockProperties: string[];
+declare const ValidationTimerLockProperties: string[];
+declare const ValidationAllLockProperties: string[];
+declare const ValidationModifiableProperties: string[];
+declare const ValidationScriptableProperties: string[];
+/** @type {Partial<Record<keyof ItemProperties, ScriptPermissionProperty>>} */
+declare const ValidationPropertyPermissions: Partial<Record<keyof ItemProperties, ScriptPermissionProperty>>;

package/bc/Scripts/VariableHeight.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Registers a variable height extended item. This automatically creates the item's load, draw and click functions.
+ * @param {Asset} asset - The asset being registered
+ * @param {VariableHeightConfig} config - The variable height configuration
+ * @param {null | ExtendedItemOption} parentOption - The extended item option of the super screen that this archetype was initialized from (if any)
+ * @returns {VariableHeightData} - The generated extended item data for the asset
+ */
+declare function VariableHeightRegister(asset: Asset, config: VariableHeightConfig, parentOption?: null | ExtendedItemOption): VariableHeightData;
+/**
+ * Parse the passed variable height draw data as passed via the extended item config
+ * @param {VariableHeightConfigDrawData} drawData - The to-be parsed draw data
+ * @return {ExtendedItemDrawData<ElementMetaData.VariableHeight>} - The parsed draw data
+ */
+declare function VariableHeightGetDrawData(drawData: VariableHeightConfigDrawData): ExtendedItemDrawData<ElementMetaData.VariableHeight>;
+/**
+ * Generates an asset's variable height data
+ * @param {Asset} asset - The asset to generate modular item data for
+ * @param {VariableHeightConfig} config - The variable height configuration
+ * @param {null | ExtendedItemOption} parentOption
+ * @returns {VariableHeightData} - The generated variable height data for the asset
+ */
+declare function VariableHeightCreateData(asset: Asset, { MaxHeight, MinHeight, DialogPrefix, ChatTags, Dictionary, GetHeightFunction, SetHeightFunction, ScriptHooks, BaselineProperty, DrawData, }: VariableHeightConfig, parentOption?: null | ExtendedItemOption): VariableHeightData;
+/**
+ * @param {VariableHeightData} data - The variable height data for the asset
+ */
+declare function VariableHeightLoad(data: VariableHeightData): void;
+/**
+ * @param {VariableHeightData} data - The variable height data for the asset
+ * @returns {void} - Nothing
+ */
+declare function VariableHeightDraw(data: VariableHeightData): void;
+/**
+ * @param {VariableHeightData} data - The variable height data for the asset
+ * @returns {void} - Nothing
+ */
+declare function VariableHeightClick(data: VariableHeightData): void;
+/**
+ * Exit handler for the item's extended item screen. Updates the character and removes UI components.
+ * @returns {void} - Nothing
+ */
+declare function VariableHeightExit(): void;
+/**
+ * Publishes a custom action to the chat for the height change
+ * @param {VariableHeightData} data
+ * @param {Character} C
+ * @param {Item} item
+ * @param {VariableHeightOption} newOption
+ * @param {VariableHeightOption} previousOption
+ */
+declare function VariableHeightPublishAction(data: VariableHeightData, C: Character, item: Item, newOption: VariableHeightOption, previousOption: VariableHeightOption): void;
+/**
+ * Retrieve the current height position override if set, accounting for inversion
+ * @param {ItemProperties} property - Property of the item determining the variable height
+ * @returns {number | null} - The height value between 0 and 1, null if missing or invalid
+ */
+declare function VariableHeightGetOverrideHeight(property: ItemProperties): number | null;
+/**
+ * Reposition the character vertically when upside-down, accounting for height ratio and inversion
+ * @param {ItemProperties} property - Property of the item determining the variable height
+ * @param {number} height - The 0 to 1 height setting to use
+ * @param {number} maxHeight - The maximum number of the item's height range
+ * @param {number} minHeight - The minimum number of the item's height range
+ * @returns {void} - Nothing
+ */
+declare function VariableHeightSetOverrideHeight(property: ItemProperties, height: number, maxHeight: number, minHeight: number): void;
+/**
+ * Initialize the variable height item properties
+ * @param {VariableHeightData} Data
+ * @param {Item} Item - The item in question
+ * @param {Character} C - The character that has the item equiped
+ * @param {boolean} Refresh -  Whether the character and relevant item should be refreshed and pushed to the server
+ * @returns {boolean} Whether properties were initialized or not
+ */
+declare function VariableHeightInit(Data: VariableHeightData, C: Character, Item: Item, Refresh: boolean): boolean;
+/**
+ * Dynamically construct the next and previous extended item option for the passed item
+ * @param {VariableHeightData} data - The extended item data
+ * @param {Item} item - The item in question
+ * @returns {{ newOption: VariableHeightOption, previousOption: VariableHeightOption }}
+ */
+declare function VariableHeightConstructOptions(data: VariableHeightData, item: Item): {
+    newOption: VariableHeightOption;
+    previousOption: VariableHeightOption;
+};
+/**
+ * Revert all item properties back to their previous state prior to opening the extended item menu
+ * @param {Character} C - The character in question
+ * @param {Item} item - The item in question
+ */
+declare function VariableHeightPropertyRevert(C: Character, item: Item): void;
+/**
+ * The name of vertical slider element
+ * @const {string}
+ */
+declare const VariableHeightSliderId: "VariableHeightSlider";
+/**
+ * The name of the numerical percentage input element
+ * @const {string}
+ */
+declare const VariableHeightNumerId: "VariableHeightNumber";
+/**
+ * A lookup for the variable height configurations for each registered variable height item
+ * @const
+ * @type {Record<string, VariableHeightData>}
+ */
+declare const VariableHeightDataLookup: Record<string, VariableHeightData>;
+/** @type {(height: number, maxHeight: number, minHeight: number, setHeight: VariableHeightSetHeightCallback, fromElementId: string) => void} */
+declare function VariableHeightChange(height: number, maxHeight: number, minHeight: number, setHeight: VariableHeightSetHeightCallback, fromElementId: string): void;

package/bc/Scripts/VibratorMode.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Registers a vibrator item. This automatically creates the item's load, draw, click and scriptDraw functions.
+ * @param {Asset} asset - The asset being registered
+ * @param {VibratingItemConfig} config - The item's vibrator item configuration
+ * @param {null | ExtendedItemOption} parentOption - The extended item option of the super screen that this archetype was initialized from (if any)
+ * @returns {VibratingItemData} - The generated extended item data for the asset
+ */
+declare function VibratorModeRegister(asset: Asset, config: VibratingItemConfig, parentOption?: null | ExtendedItemOption): VibratingItemData;
+/**
+ * Sets an extended item's type and properties to the option provided.
+ * @param {VibratingItemData} data - The extended item data
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose type to set
+ * @param {VibratingItemOption} newOption - The to-be applied extended item option
+ * @param {VibratingItemOption} previousOption - The previously applied extended item option
+ * @param {boolean} [push] - Whether or not appearance updates should be persisted (only applies if the character is the
+ * player) - defaults to false.
+ */
+declare function VibratorModeSetOption(data: VibratingItemData, C: Character, item: Item, newOption: VibratingItemOption, previousOption: VibratingItemOption, push?: boolean): void;
+/**
+ * Parse the passed typed item draw data as passed via the extended item config
+ * @param {readonly VibratorModeSet[]} modeSet - The vibrator mode sets for the item
+ * @param {ExtendedItemConfigDrawData<{ drawImage?: false }> | undefined} drawData - The to-be parsed draw data
+ * @param {number} y - The y-coordinate at which to start drawing the controls
+ * @return {ExtendedItemDrawData<ElementMetaData.Vibrating>} - The parsed draw data
+ */
+declare function VibratorModeGetDrawData(modeSet: readonly VibratorModeSet[], drawData: ExtendedItemConfigDrawData<{
+    drawImage?: false;
+}> | undefined, y?: number): ExtendedItemDrawData<ElementMetaData.Vibrating>;
+/**
+ * Generates an asset's vibrating item data
+ * @param {Asset} asset - The asset to generate vibrating item data for
+ * @param {VibratingItemConfig} config - The item's extended item configuration
+ * @returns {VibratingItemData} - The generated vibrating item data for the asset
+ */
+declare function VibratorModeCreateData(asset: Asset, { Options, ScriptHooks, BaselineProperty, Dictionary, DialogPrefix, DrawData, ChatTags }: VibratingItemConfig, parentOption?: any): VibratingItemData;
+/**
+ * Gather all extended item options for a given list of modes.
+ * @param {VibratingItemData} data - The extended item data
+ * @param {readonly VibratorModeSet[]} modeSet - The vibrator mods
+ * @returns {VibratingItemOption[]} - The generated vibrating item options
+ */
+declare function VibratorModeGetOptions(data: VibratingItemData, modeSet: readonly VibratorModeSet[]): VibratingItemOption[];
+/**
+ * Loads the vibrating item's extended item menu.
+ * @param {VibratingItemData} data
+ */
+declare function VibratorModeLoad({ dialogPrefix: { header } }: VibratingItemData): void;
+/**
+ * @param {VibratingItemData} data
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose options are being validated
+ * @param {VibratingItemOption} newOption - The new option
+ * @param {VibratingItemOption} previousOption - The previously applied option
+ * @returns {string|undefined} - undefined or an empty string if the validation passes. Otherwise, returns a string
+ * message informing the player of the requirements that are not met.
+ */
+declare function VibratorModeValidate(data: VibratingItemData, C: Character, item: Item, newOption: VibratingItemOption, previousOption: VibratingItemOption): string | undefined;
+/**
+ * Publish a vibrator action and exit the dialog of applicable
+ * @param {VibratingItemData} data
+ * @param {Character} C - The character wearing the item
+ * @param {Item} item - The item in question
+ * @param {VibratingItemOption} newOption - The newly selected option
+ * @param {VibratingItemOption} previousOption - The currently selected option
+ */
+declare function VibratorModePublishAction(data: VibratingItemData, C: Character, item: Item, newOption: VibratingItemOption, previousOption: VibratingItemOption): void;
+/**
+ * Sets asset properties common to all vibrating items
+ * @param {VibratingItemData} data - The vibrating item data for the asset
+ * @returns {void} - Nothing
+ */
+declare function VibratorModeSetAssetProperties(data: VibratingItemData): void;
+/**
+ * Sets the AllowEffect property for a vibrating item
+ * @param {VibratingItemData} data - The vibrating item data for the asset
+ * @returns {void} - Nothing
+ */
+declare function VibratorModeSetAllowEffect({ asset, modeSet }: VibratingItemData): void;
+/**
+ * @typedef {{ Mode?: VibratorMode, ChangeTime?: number, LastChange?: number }} VibratorModePersistentData
+ */
+/**
+ * Common dynamic script draw function for vibrators. This function is called every frame. TO make use of dynamic script draw on vibrators,
+ * ensure your item has a `Assets<AssetGroup><AssetName>ScriptDraw` function defined that calls this function, and that your asset
+ * definition in Female3DCG.js has `DynamicScriptDraw: true` set. See the Heart Piercings for examples.
+ * @param {VibratingItemData} data
+ * @param {DynamicScriptCallbackData<VibratorModePersistentData>} drawData
+ */
+declare function VibratorModeScriptDraw(data: VibratingItemData, drawData: DynamicScriptCallbackData<VibratorModePersistentData>): void;
+/**
+ * Vibrator update function for vibrator state machine modes
+ * @param {VibratingItemData} data - The vibrating item data
+ * @param {Character} C - The character that the item is equipped on
+ * @param {Item} item - The item that is being updated
+ * @param {VibratorModePersistentData} persistentData - Persistent animation data for the item
+ * @param {readonly VibratorModeState[]} transitionsFromDefault - The possible vibrator states that may be transitioned to from
+ * the default state
+ * @returns {void} - Nothing
+ */
+declare function VibratorModeUpdateStateBased(data: VibratingItemData, C: Character, item: Item, persistentData: VibratorModePersistentData, transitionsFromDefault: readonly VibratorModeState[]): void;
+/**
+ * Publishes a chatroom message for an automatic change in vibrator intensity. Does nothing if the vibrator's intensity
+ * did not change.
+ * @param {VibratingItemData} data
+ * @param {Character} C - The character that the vibrator is equipped on
+ * @param {Item} item - The vibrator item
+ * @param {number} oldIntensity - The previous intensity of the vibrator
+ * @param {number} newIntensity - The new intensity of the vibrator
+ * @returns {void} - Nothing
+ */
+declare function VibratorModePublish(data: VibratingItemData, C: Character, item: Item, oldIntensity: number, newIntensity: number): void;
+/**
+ * Initialize the vibrating item properties
+ * @param {VibratingItemData} data
+ * @param {Item} Item - The item in question
+ * @param {Character} C - The character that has the item equiped
+ * @param {boolean} Refresh - Whether the character and relevant item should be refreshed and pushed to the server
+ * @returns {boolean} Whether properties were initialized or not
+ */
+declare function VibratorModeInit(data: VibratingItemData, C: Character, Item: Item, Refresh?: boolean): boolean;
+/**
+ * An alias for {@link TypedItemSetOptionByName}.
+ * @type {typeof TypedItemSetOptionByName}
+ */
+declare function VibratorModeSetOptionByName(C: Character, itemOrGroupName: AssetGroupName | Item, optionName: string, push?: boolean, C_Source?: Character, subscreen?: [archetype: "typed" | "vibrating", screen: string]): string;
+/**
+ * Return the (standard) vibrator mode one would get by incrementing/decrementing the passed mode.
+ * @param {VibratorMode} mode - The current vibrator mode
+ * @param {boolean} decrement - Whether the mode should be decremented rather than incremented
+ * @returns {VibratorMode} The new vibrator mode
+ */
+declare function VibratorModeIntensityIncrement(mode: VibratorMode, decrement?: boolean): VibratorMode;
+/**
+ * An enum for the possible vibrator modes
+ * @readonly
+ * @type {{OFF: "Off", LOW: "Low", MEDIUM: "Medium", HIGH: "High", MAXIMUM: "Maximum", RANDOM: "Random", ESCALATE: "Escalate", TEASE: "Tease", DENY: "Deny", EDGE: "Edge"}}
+ */
+declare var VibratorMode: {
+    OFF: "Off";
+    LOW: "Low";
+    MEDIUM: "Medium";
+    HIGH: "High";
+    MAXIMUM: "Maximum";
+    RANDOM: "Random";
+    ESCALATE: "Escalate";
+    TEASE: "Tease";
+    DENY: "Deny";
+    EDGE: "Edge";
+};
+/**
+ * An enum for the possible vibrator states when a vibrator is in a state machine mode
+ * @type {{DEFAULT: "Default", DENY: "Deny", ORGASM: "Orgasm", REST: "Rest"}}
+ */
+declare var VibratorModeState: {
+    DEFAULT: "Default";
+    DENY: "Deny";
+    ORGASM: "Orgasm";
+    REST: "Rest";
+};
+/**
+ * An enum for the vibrator configuration sets that a vibrator can have
+ * @type {{STANDARD: "Standard", ADVANCED: "Advanced"}}
+ */
+declare var VibratorModeSet: {
+    STANDARD: "Standard";
+    ADVANCED: "Advanced";
+};
+/**
+ * A record of the various available vibrator sets of vibrator modes
+ * @type {{
+ *     Standard: VibratingItemOptionConfig[],
+ *     Advanced: VibratingItemOptionConfig[],
+ * }}
+ * @constant
+ */
+declare var VibratorModeOptions: {
+    Standard: VibratingItemOptionConfig[];
+    Advanced: VibratingItemOptionConfig[];
+};
+/**
+ * An alias for the vibrators OFF mode. See {@link VibratorModeOptions}.
+ */
+declare const VibratorModeOff: VibratingItemOptionConfig;
+/** A list with all advanced vibrator mode-names. */
+declare const VibratorModesAdvanced: VibratorMode[];
+/**
+ * A lookup for the vibrator configurations for each registered vibrator item
+ * @const
+ * @type {Record<string, VibratingItemData>}
+ */
+declare const VibratorModeDataLookup: Record<string, VibratingItemData>;
+/**
+ * Namespace with helper functions for {@link VibratorModeScriptDraw}
+ * @type {Partial<Record<VibratorMode, (data: VibratingItemData, C: Character, item: Item, persistentData: VibratorModePersistentData) => void>>}
+ * @namespace
+ */
+declare const VibratorModeUpdate: Partial<Record<VibratorMode, (data: VibratingItemData, C: Character, item: Item, persistentData: VibratorModePersistentData) => void>>;
+declare namespace VibratorModeStateUpdate {
+    function Default(C: Character, arousal: number, timeSinceLastChange: number, oldIntensity: VibratorIntensity, transitionsFromDefault: readonly VibratorModeState[]): StateAndIntensity;
+    function Deny(C: Character, arousal: number, timeSinceLastChange: number, oldIntensity: VibratorIntensity): StateAndIntensity;
+    function Orgasm(C: Character, arousal: number, timeSinceLastChange: number, oldIntensity: VibratorIntensity): StateAndIntensity;
+    function Rest(C: Character, arousal: number, timeSinceLastChange: number, oldIntensity: VibratorIntensity): StateAndIntensity;
+}
+type VibratorModePersistentData = {
+    Mode?: VibratorMode;
+    ChangeTime?: number;
+    LastChange?: number;
+};

package/bc/Scripts/lib/LZString.d.ts

@@ -0,0 +1,12 @@
+export function compressToBase64(input: any): string;
+export function decompressFromBase64(input: any): string;
+export function compressToUTF16(input: any): string;
+export function decompressFromUTF16(compressed: any): string;
+export function compressToUint8Array(uncompressed: any): Uint8Array;
+export function decompressFromUint8Array(compressed: any): string;
+export function compressToEncodedURIComponent(input: any): string;
+export function decompressFromEncodedURIComponent(input: any): string;
+export function compress(uncompressed: any): string;
+export function _compress(uncompressed: any, bitsPerChar: any, getCharFromInt: any): string;
+export function decompress(compressed: any): string;
+export function _decompress(length: any, resetValue: any, getNextValue: any): string;