bc-stubs 131.0.0-Alpha.1 → 131.0.0-Beta.2

package/bc/NativeDeclarations/Assets/Female3DCG/Female3DCG_Types.d.ts

@@ -1331,6 +1331,7 @@ interface VibratingItemOption extends Omit<VibratingItemOptionConfig, "Archetype
 	ParentData: VibratingItemData;
 	Property: ItemProperties & Pick<Required<ItemProperties>, "TypeRecord" | "Intensity" | "Effect">;
 	ArchetypeData?: null;
+	Advanced: boolean;
 }
 
 /** An object defining all of the required configuration for registering a vibrator item */

package/bc/NativeDeclarations/Scripts/Typedef.d.ts

@@ -2721,7 +2721,7 @@ interface ExtendedItemDialog<
 	OptionType extends ExtendedItemOption,
 > {
 	/** The dialogue prefix for the player prompt that is displayed on each module's menu screen */
-	header: string | ExtendedItemHeaderCallback<DataType>;
+	header?: string | ExtendedItemHeaderCallback<DataType>;
 	/** The dialogue prefix for the name of each module */
 	module?: string;
 	/** The dialogue prefix for the name of each option */
@@ -2867,7 +2867,7 @@ declare namespace ExtendedItemCallbacks {
 	 */
 	type Validate<
 		OptionType extends ExtendedItemOption = ExtendedItemOption
-	> = ExtendedItemCallback<[C: Character, item: Item, newOption: OptionType, previousOption: OptionType, permitExisting?: boolean], string>;
+	> = ExtendedItemCallback<[C: Character, item: Item, newOption: OptionType, previousOption: OptionType, permitExisting?: boolean], string | null>;
 	/**
 	 * Callback for extended item `PublishAction` functions.
 	 * `PublishAction` functions are responsible for reporting any changes to an item's properties via a chat message.
@@ -2985,7 +2985,7 @@ declare namespace ExtendedItemScriptHookCallbacks {
 	type Validate<
 		DataType extends ExtendedItemData<any>,
 		OptionType extends ExtendedItemOption
-	> = ExtendedItemScriptHookCallback<DataType, [C: Character, item: Item, newOption: OptionType, previousOption: OptionType, permitExisting?: boolean], string>;
+	> = ExtendedItemScriptHookCallback<DataType, [C: Character, item: Item, newOption: OptionType, previousOption: OptionType, permitExisting?: boolean], string | undefined>;
 	/**
 	 * Callback for extended item `PublishAction` script hooks.
 	 * `PublishAction` functions are responsible for reporting any changes to an item's properties via a chat message.
@@ -3324,6 +3324,17 @@ interface ItemPropertiesBase {
 	/** KD modules */
 	// FIXME: Note that, as far as I can see, it's only ever set, never read
 	Modules?: number[];
+
+	/** Transformation properties */
+	TranslationX?: number;
+	TranslationY?: number;
+
+	/** Scale is currently limited from 0.01 to 3.00 (3 times the size) */
+	ScaleX?: number;
+	ScaleY?: number;
+
+	/** Rotation is in degrees from -180 to 180 */
+	Rotation?: number;
 }
 
 /**
@@ -3532,7 +3543,17 @@ interface ItemPropertiesCustom {
 	// #endregion
 }
 
-interface ItemProperties extends ItemPropertiesBase, AssetDefinitionProperties, ItemPropertiesCustom { }
+interface ItemProperties extends ItemPropertiesBase, AssetDefinitionProperties, ItemPropertiesCustom {
+	LayerTranslationX?: Record<string, number | undefined>;
+	/** Translation Y */
+	LayerTranslationY?: Record<string, number | undefined>;
+	/** Scale X */
+	LayerScaleX?: Record<string, number | undefined>;
+	/** Scale Y */
+	LayerScaleY?: Record<string, number | undefined>;
+	/** Rotation */
+	LayerRotation?: Record<string, number | undefined>;
+}
 
 /** Base type for unparsed extended item properties */
 interface ItemPropertiesConfig extends Omit<ItemProperties, "DrawingTop" | "DrawingLeft"> {
@@ -3900,7 +3921,7 @@ interface NoArchItemData extends ExtendedItemData<NoArchItemOption> {
 	drawData: ExtendedItemDrawData<ElementMetaData.NoArch>;
 	dialogPrefix: {
 		/** The dialog key for the item's load text (usually a prompt to select the type) */
-		header: string | ExtendedItemHeaderCallback<NoArchItemData>;
+		header?: string | ExtendedItemHeaderCallback<NoArchItemData>;
 		/** The prefix used for dialog keys representing the display names of the item's types */
 		option?: string;
 		/** The prefix used for dialog keys representing the item's chatroom messages when its type is changed */
@@ -4135,6 +4156,16 @@ type DrawOptions = {
 	Mirror?: boolean;
 	/** Zoom factor */
 	Zoom?: number;
+	/** Translation X */
+	TranslationX?: number;
+	/** Translation Y */
+	TranslationY?: number;
+	/** Scale X */
+	ScaleX?: number;
+	/** Scale Y */
+	ScaleY?: number;
+	/** Rotation */
+	Rotation?: number;
 	/* Color of the image to draw */
 	HexColor?: HexColor;
 	/* Whether or not it is drawn in full alpha mode */
@@ -4792,6 +4823,7 @@ interface LogNameType {
 		| "ReleasedCollar"
 		| LogNameAdvanced
 		| "ForbiddenWords"
+		| "ForbiddenWordsMute"
 	),
 	PrivateRoom: (
 		"RentRoom"

package/bc/NativeDeclarations/Scripts/lib/webgl/resources/m4.d.ts

@@ -1 +1,281 @@
-declare const m4: any;
+// NOTE: The matching (minified) .js files appears to be based on an unknown predecessor of https://github.com/greggman/twgl.js
+// Docstrings have been supplemented with those from https://github.com/greggman/twgl.js/releases/tag/v0.0.1 (Copyright 2015, Gregg Tavares, MIT)
+
+/**
+ * Copyright 2014, Gregg Tavares.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Gregg Tavares. nor the names of his
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+declare namespace m4 {
+	/** A [4, 4] matrix represented as a flattened length-16 array */
+	type Mat4 = Float32Array;
+	/** A length-3 vector */
+	type Vec3 = Float32Array;
+	/** A length-4 vector */
+	type Vec4 = Float32Array;
+
+	/**
+	 * Copies a matrix.
+	 * @param {Mat4} m The matrix.
+	 * @param {Mat4?} dst The matrix.
+	 * @return {Mat4} A copy of m.
+	 */
+	function copy(m: m4.Mat4, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Computes a 4-by-4 look-at transformation.
+	 *
+	 * This is a matrix which positions the camera itself. If you want
+	 * a view matrix (a matrix which moves things in front of the camera)
+	 * take the inverse of this.
+	 *
+	 * @param {Vec3} eye The position of the eye.
+	 * @param {Vec3} target The position meant to be viewed.
+	 * @param {Vec3} up A vector pointing up.
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} The look-at matrix.
+	 */
+	function lookAt(eye: m4.Vec3, target: m4.Vec3, up: m4.Vec3, dst?: m4.Mat4): m4.Mat4;
+	function addVectors(vec1: m4.Vec3, vec2: m4.Vec3, dst?: m4.Vec3): m4.Vec3;
+	function subtractVectors(vec1: m4.Vec3, vec2: m4.Vec3, dst?: m4.Vec3): m4.Vec3;
+	function distance(vec1: m4.Vec3, vec2: m4.Vec3): number;
+	function distanceSq(vec1: m4.Vec3, vec2: m4.Vec3): number;
+	/**
+	 * Divides a vector by its Euclidean length and returns the quotient.
+	 * @param {Vec3} a The vector.
+	 * @param {Vec3?} dst vector to hold result. If not new one is created..
+	 * @return {Vec3} The normalized vector.
+	 */
+	function normalize(a: m4.Vec3, dst?: m4.Vec3): m4.Vec3;
+	function compose(m: m4.Mat4, a: number, b: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Computes the cross product of two vectors; assumes both vectors have
+	 * three entries.
+	 * @param {Vec3} a Operand vector.
+	 * @param {Vec3} b Operand vector.
+	 * @param {Vec3?} dst vector to hold result. If not new one is created..
+	 * @return {Vec3} The vector a cross b.
+	 */
+	function cross(a: m4.Vec3, b: m4.Vec3, dst?: m4.Vec3): m4.Vec3;
+	function decompose(a: m4.Mat4, b: m4.Mat4, c: m4.Mat4, dst: m4.Mat4): m4.Mat4;
+	/**
+	 * Computes the dot product of two vectors; assumes both vectors have
+	 * three entries.
+	 * @param {Vec3} a Operand vector.
+	 * @param {Vec3} b Operand vector.
+	 * @return {number} dot product
+	 */
+	function dot(a: m4.Vec3, b: m4.Vec3): number;
+	/**
+	 * Creates an n-by-n identity matrix.
+	 *
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} An n-by-n identity matrix.
+	 */
+	function identity(dst?: m4.Mat4): number;
+	/**
+	 * Takes the transpose of a matrix.
+	 * @param {Mat4} m The matrix.
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} The transpose of m.
+	 */
+	function transpose(m: m4.Mat4, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Computes the length of vector
+	 * @param {Vec3} v vector.
+	 * @return {number} length of vector.
+	 */
+	function length(v: m4.Vec3): number;
+	function orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Computes a 4-by-4 perspective transformation matrix given the left, right,
+	 * top, bottom, near and far clipping planes. The arguments define a frustum
+	 * extending in the negative z direction. The arguments near and far are the
+	 * distances to the near and far clipping planes. Note that near and far are not
+	 * z coordinates, but rather they are distances along the negative z-axis. The
+	 * matrix generated sends the viewing frustum to the unit box. We assume a unit
+	 * box extending from -1 to 1 in the x and y dimensions and from 0 to 1 in the z
+	 * dimension.
+	 * @param {number} left The x coordinate of the left plane of the box.
+	 * @param {number} right The x coordinate of the right plane of the box.
+	 * @param {number} bottom The y coordinate of the bottom plane of the box.
+	 * @param {number} top The y coordinate of the right plane of the box.
+	 * @param {number} near The negative z coordinate of the near plane of the box.
+	 * @param {number} far The negative z coordinate of the far plane of the box.
+	 * @param {Mat4?} dst Output matrix.
+	 * @return {Mat4} The perspective projection matrix.
+	 */
+	function frustum(left: number, right: number, bottom: number, top: number, near: number, far: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Computes a 4-by-4 perspective transformation matrix given the angular height
+	 * of the frustum, the aspect ratio, and the near and far clipping planes.  The
+	 * arguments define a frustum extending in the negative z direction.  The given
+	 * angle is the vertical angle of the frustum, and the horizontal angle is
+	 * determined to produce the given aspect ratio.  The arguments near and far are
+	 * the distances to the near and far clipping planes.  Note that near and far
+	 * are not z coordinates, but rather they are distances along the negative
+	 * z-axis.  The matrix generated sends the viewing frustum to the unit box.
+	 * We assume a unit box extending from -1 to 1 in the x and y dimensions and
+	 * from 0 to 1 in the z dimension.
+	 * @param {number} fieldOfViewYInRadians The camera angle from top to bottom (in radians).
+	 * @param {number} aspect The aspect ratio width / height.
+	 * @param {number} zNear The depth (negative z coordinate)
+	 *     of the near clipping plane.
+	 * @param {number} zFar The depth (negative z coordinate)
+	 *     of the far clipping plane.
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} The perspective matrix.
+	 */
+	function perspective(fieldOfViewYInRadians: number, aspect: number, zNear: number, zFar: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Creates a 4-by-4 matrix which translates by the given vector v.
+	 * @param {number} x X component of the vector by which to translate
+	 * @param {number} y Y component of the vector by which to translate
+	 * @param {number} z Z component of the vector by which to translate
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} The translation matrix.
+	 */
+	function translation(x: number, y: number, z: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Modifies the given 4-by-4 matrix by translation by the given vector v.
+	 * @param {Mat4} m The matrix.
+	 * @param {number} x X component of the vector by which to translate
+	 * @param {number} y Y component of the vector by which to translate
+	 * @param {number} z Z component of the vector by which to translate
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} m once modified.
+	 */
+	function translate(m: m4.Mat4, x: number, y: number, z: number, dst?: m4.Mat4): m4.Mat4;
+	function xRotation(angleInRadians: number, dst?: m4.Mat4): m4.Mat4;
+	function yRotation(angleInRadians: number, dst?: m4.Mat4): m4.Mat4;
+	function zRotation(angleInRadians: number, dst?: m4.Mat4): m4.Mat4;
+	function xRotate(m: m4.Mat4, angleInRadians: number, dst?: m4.Mat4): m4.Mat4;
+	function yRotate(m: m4.Mat4, angleInRadians: number, dst?: m4.Mat4): m4.Mat4;
+	function zRotate(m: m4.Mat4, angleInRadians: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Creates a 4-by-4 matrix which rotates around the given axis by the given
+	 * angle.
+	 * @param {Vec3} axis The axis
+	 *     about which to rotate.
+	 * @param {number} angleInRadians The angle by which to rotate (in radians).
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} A matrix which rotates angle radians
+	 *     around the axis.
+	 */
+	function axisRotation(axis: m4.Vec3, angleInRadians: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Modifies the given 4-by-4 matrix by rotation around the given axis by the
+	 * given angle.
+	 * @param {Mat4} m The matrix.
+	 * @param {Vec3} axis The axis
+	 *     about which to rotate.
+	 * @param {number} angleInRadians The angle by which to rotate (in radians).
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} m once modified.
+	 */
+	function axisRotate(m: m4.Mat4, axis: m4.Vec3, angleInRadians: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Creates a 4-by-4 matrix which scales in each dimension by an amount given by
+	 * the corresponding entry in the given vector; assumes the vector has three
+	 * entries.
+	 * @param {number} x X component of the vector by which to scale
+	 * @param {number} y Y component of the vector by which to scale
+	 * @param {number} z Z component of the vector by which to scale
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} The scaling matrix.
+	 */
+	function scaling(x: number, y: number, z: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Modifies the given 4-by-4 matrix, scaling in each dimension by an amount
+	 * given by the corresponding entry in the given vector; assumes the vector has
+	 * three entries.
+	 * @param {Mat4} m The matrix to be modified.
+	 * @param {number} x X component of the vector by which to scale
+	 * @param {number} y Y component of the vector by which to scale
+	 * @param {number} z Z component of the vector by which to scale
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} m once modified.
+	 */
+	function scale(m: m4.Mat4, x: number, y: number, z: number, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Multiplies two 4-by-4 matrices; assumes that the given matrices are 4-by-4;
+	 * assumes matrix entries are accessed in [row][column] fashion.
+	 * @param {Mat4} a The matrix on the left.
+	 * @param {Mat4} b The matrix on the right.
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} The matrix product of a and b.
+	 */
+	function multiply(a: m4.Mat4, b: m4.Mat4, dst?: m4.Mat4): m4.Mat4;
+	/**
+	 * Computes the inverse of a 4-by-4 matrix.
+	 * @param {Mat4} m The matrix.
+	 * @param {Mat4?} dst matrix to hold result. If none new one is created..
+	 * @return {Mat4} The inverse of m.
+	 */
+	function inverse(m: m4.Mat4, dst?: m4.Mat4): m4.Mat4;
+	function transformVector(a: m4.Vec4, b: m4.Vec4, dst?: m4.Vec4): m4.Vec4;
+	/**
+	 * Takes a 4-by-4 matrix and a vector with 3 entries,
+	 * interprets the vector as a point, transforms that point by the matrix, and
+	 * returns the result as a vector with 3 entries.
+	 * @param {Mat4} m The matrix.
+	 * @param {Vec3} v The point.
+	 * @param {Vec3} dst optional vec3 to store result
+	 * @return {Vec3} dst or new vec3 if not provided
+	 */
+	function transformPoint(m: m4.Mat4, v: m4.Vec3, dst?: m4.Vec3): m4.Vec3;
+	/**
+	 * Takes a 4-by-4 matrix and a vector with 3 entries, interprets the vector as a
+	 * direction, transforms that direction by the matrix, and returns the result;
+	 * assumes the transformation of 3-dimensional space represented by the matrix
+	 * is parallel-preserving, i.e. any combination of rotation, scaling and
+	 * translation, but not a perspective distortion. Returns a vector with 3
+	 * entries.
+	 * @param {Mat4} m The matrix.
+	 * @param {Vec3} v The direction.
+	 * @param {Vec3} dst optional Vec3 to store result
+	 * @return {Vec3} dst or new Vec3 if not provided
+	 */
+	function transformDirection(m: m4.Mat4, v: m4.Vec3, dst?: m4.Vec3): m4.Vec3;
+	/**
+	 * Takes a 4-by-4 matrix m and a vector v with 3 entries, interprets the vector
+	 * as a normal to a surface, and computes a vector which is normal upon
+	 * transforming that surface by the matrix. The effect of this function is the
+	 * same as transforming v (as a direction) by the inverse-transpose of m.  This
+	 * function assumes the transformation of 3-dimensional space represented by the
+	 * matrix is parallel-preserving, i.e. any combination of rotation, scaling and
+	 * translation, but not a perspective distortion.  Returns a vector with 3
+	 * entries.
+	 * @param {Mat4} m The matrix.
+	 * @param {Vec3} v The normal.
+	 * @param {Vec3?} dst The direction.
+	 * @return {Vec3} The transformed direction.
+	 */
+	function transformNormal(m: m4.Mat4, v: m4.Vec3, dst?: m4.Vec3): m4.Vec3;
+	/** Do not touch */
+	const setDefaultType: never;
+}

package/bc/Screens/Inventory/Futuristic/Futuristic.d.ts

@@ -32,7 +32,7 @@ declare function FuturisticAccessDraw(Data: ExtendedItemData<any>, OriginalFunct
  * @returns {void} - Nothing
  */
 declare function FuturisticAccessExit(): void;
-declare function FuturisticAccessValidate(data: ExtendedItemData<any>, originalFunction: ((C: Character, item: Item, newOption: any, previousOption: any, permitExisting?: boolean | undefined) => string) | null, C: Character, item: Item, newOption: any, previousOption: any, permitExisting?: boolean | undefined): string;
+declare function FuturisticAccessValidate(data: ExtendedItemData<any>, originalFunction: ((C: Character, item: Item, newOption: any, previousOption: any, permitExisting?: boolean | undefined) => string | undefined) | null, C: Character, item: Item, newOption: any, previousOption: any, permitExisting?: boolean | undefined): string | undefined;
 declare function InventoryItemFuturisticLoadAccessDenied(): void;
 /**
  * Draw the futuristic item ACCESS DENIED screen
@@ -49,9 +49,9 @@ declare function InventoryItemFuturisticClickAccessDenied(data: ExtendedItemData
  * @param {Character} C - The character to validate the option
  * @param {Item | null} Item - The equipped item
  * @param {boolean} [changeWhenLocked] - See {@link ExtendedItemOption.ChangeWhenLocked}
- * @returns {string} - Returns false and sets DialogExtendedMessage, if the chosen option is not possible.
+ * @returns {string | null} - Returns an explanation for the failed validation if the chosen option is not possible, or null.
  */
-declare function InventoryItemFuturisticValidate(C: Character, Item?: Item | null, changeWhenLocked?: boolean): string;
+declare function InventoryItemFuturisticValidate(C: Character, Item?: Item | null, changeWhenLocked?: boolean): string | null;
 /**
  * Publish a chat message for denied access.
  *

package/bc/Screens/Inventory/ItemHead/DroneMask/DroneMask.d.ts

@@ -1,2 +1,2 @@
-declare function ItemHeadDroneMaskValidateHook(data: ModularItemData, originalFunction: ((C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, permitExisting?: boolean | undefined) => string) | null, C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, permitExisting?: boolean | undefined): string;
+declare function ItemHeadDroneMaskValidateHook(data: ModularItemData, originalFunction: ((C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, permitExisting?: boolean | undefined) => string | undefined) | null, C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, permitExisting?: boolean | undefined): string | undefined;
 declare function AssetsItemHeadDroneMaskAfterDrawHook(data: TextItemData, originalFunction: ((drawData: DynamicDrawingData<AnimationPersistentData>) => void) | null, drawData: DynamicDrawingData<AnimationPersistentData>): void;

package/bc/Screens/Inventory/ItemPelvis/LoveChastityBelt/LoveChastityBelt.d.ts

@@ -1,5 +1,5 @@
 declare function InventoryItemPelvisLoveChastityBeltDrawHook(data: ModularItemData, originalFunction: () => void): void;
 declare function InventoryItemPelvisLoveChastityBeltSetOptionHook(data: ModularItemData, originalFunction: ((C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, push: boolean, refresh: boolean) => void) | null, C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, push: boolean, refresh: boolean): void;
-declare function InventoryItemPelvisLoveChastityBeltValidateHook(data: ModularItemData, originalFunction: ((C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, permitExisting?: boolean | undefined) => string) | null, C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, permitExisting?: boolean | undefined): string;
+declare function InventoryItemPelvisLoveChastityBeltValidateHook(data: ModularItemData, originalFunction: ((C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, permitExisting?: boolean | undefined) => string | undefined) | null, C: Character, item: Item, newOption: ModularItemOption, previousOption: ModularItemOption, permitExisting?: boolean | undefined): string | undefined;
 /** Map the names of the love chastity belt front + black shield options to its scifi pleasure panties equivalent. */
 declare const InventoryItemPelvisLoveChastityBeltCrotchShield: Map<string, string>;

package/bc/Screens/Online/AdvancedRule/AdvancedRule.d.ts

@@ -7,7 +7,7 @@ declare function AdvancedRuleLoad(): Promise<void>;
 declare function AdvancedRuleOpen(RuleType: LogNameAdvanced): void;
 /**
  * Convert an option to its descriptive name
- * @param {AdvancedRuleType} type
+ * @param {LogNameAdvanced} type
  * @param {string} option
  */
 declare function AdvancedRuleTextGet(type: LogNameAdvanced, option: string): string;

package/bc/Scripts/Dialog.d.ts

@@ -278,10 +278,10 @@ declare function DialogHasKey(C: Character, item: Item): boolean;
 /**
  * Checks whether the player is able to unlock the provided item on the provided character
  * @param {Character} C - The character on whom the item is equipped
- * @param {Item} Item - The item that should be unlocked
+ * @param {Item} item - The item that should be unlocked
  * @returns {boolean} - Returns true, if the player can unlock the given item, false otherwise
  */
-declare function DialogCanUnlock(C: Character, Item: Item): boolean;
+declare function DialogCanUnlock(C: Character, item: Item): boolean;
 /**
  * Checks whether we can lockpick a lock.
  * @param {Character} C

package/bc/Scripts/Element.d.ts

@@ -108,7 +108,7 @@ declare function ElementCreateDropdown(id: string | null, optionsList: readonly
     name?: string;
 }, htmlOptions?: null | Partial<Record<"select", Omit<HTMLOptions<"select">, "tag">>>): HTMLSelectElement;
 /**
- * Construct a custom searchable dropdown menu.
+ * Construct a custom searchable dropdown menu or, on mobile, a conventional `<select>` element.
  *
  * The element comprises a button trigger displaying the current selection,
  * and a popup containing a search input and a scrollable list of options.
@@ -134,9 +134,9 @@ declare function ElementCreateDropdown(id: string | null, optionsList: readonly
  * @param {readonly ElementSearchableDropdown.OptionItem[]} optionsList - The available options.
  * @param {(value: string) => void} onChange - Called when the selection changes.
  * @param {ElementSearchableDropdown.CreateOptions | null} [options]
- * @returns {ElementSearchableDropdown.SearchableDropdownElement}
+ * @returns {ElementSearchableDropdown.SearchableDropdownElement | HTMLSelectElement}
  */
-declare function ElementCreateSearchableDropdown(id: string | null, optionsList: readonly ElementSearchableDropdown.OptionItem[], onChange: (value: string) => void, options?: ElementSearchableDropdown.CreateOptions | null): ElementSearchableDropdown.SearchableDropdownElement;
+declare function ElementCreateSearchableDropdown(id: string | null, optionsList: readonly ElementSearchableDropdown.OptionItem[], onChange: (value: string) => void, options?: ElementSearchableDropdown.CreateOptions | null): ElementSearchableDropdown.SearchableDropdownElement | HTMLSelectElement;
 /**
  * Creates a new div element in the main document. Does not create a new element if there is already an existing one with the same ID
  * @param {string | null} ID - The id of the div tag to create.

package/bc/Scripts/ExtendedItem.d.ts

@@ -119,24 +119,23 @@ declare function ExtendedItemRequirementCheckMessage<T extends ExtendedItemOptio
  * wearer may select the option)
  * @param {Character} C - The character on whom the bondage is applied
  * @param {ExtendedItemOption} Option - The option whose requirements should be checked against
- * @returns {string | undefined} - undefined if the
+ * @returns {string | null} - undefined if the
  */
-declare function ExtendedItemCheckSelfSelect(C: Character, Option: ExtendedItemOption): string | undefined;
+declare function ExtendedItemCheckSelfSelect(C: Character, Option: ExtendedItemOption): string | null;
 /**
  * Checks whether the player meets an option's self-bondage/bondage skill level requirements
  * @param {Character} C - The character on whom the bondage is applied
  * @param {Item} Item - The item whose options are being checked
  * @param {ExtendedItemOption} Option - The option whose requirements should be checked against
- * @returns {string|undefined} - undefined if the player meets the option's skill level requirements. Otherwise returns
- * a string message informing them of the requirements they do not meet.
+ * @returns {string|null} - Returns a string message informing them of the requirements they do not meet, otherwise null.
  */
-declare function ExtendedItemCheckSkillRequirements(C: Character, Item: Item, Option: ExtendedItemOption): string | undefined;
+declare function ExtendedItemCheckSkillRequirements(C: Character, Item: Item, Option: ExtendedItemOption): string | null;
 /**
  * Checks whether the character meets an option's required bought items
  * @param {ExtendedItemOption} Option - The option being checked
- * @returns {string|undefined} undefined if the requirement is met, otherwise the error message
+ * @returns {string|null} undefined if the requirement is met, otherwise the error message
  */
-declare function ExtendedItemCheckBuyGroups(Option: ExtendedItemOption): string | undefined;
+declare function ExtendedItemCheckBuyGroups(Option: ExtendedItemOption): string | null;
 /**
  * Checks whether a change from the given current option to the newly selected option is valid.
  * @template {ExtendedItemOption} T
@@ -147,9 +146,9 @@ declare function ExtendedItemCheckBuyGroups(Option: ExtendedItemOption): string
  * @param {T} previousOption - The currently applied option on the item
  * @param {boolean} [permitExisting] - Determines whether the validation should allow the new option and previous option
  * to be identical. Defaults to false.
- * @returns {string} - Returns a non-empty message string if the item failed validation, or an empty string otherwise
+ * @returns {string | null} - Returns a reason if the item failed validation, or null otherwise
  */
-declare function ExtendedItemValidate<T extends ExtendedItemOption>(data: null | ExtendedItemData<T>, C: Character, Item: Item, newOption: T, previousOption: T, permitExisting?: boolean): string;
+declare function ExtendedItemValidate<T extends ExtendedItemOption>(data: null | ExtendedItemData<T>, C: Character, Item: Item, newOption: T, previousOption: T, permitExisting?: boolean): string | null;
 /**
  * Simple getter for the function prefix used for the passed extended item - used for calling standard
  * extended item functions (e.g. if the currently focused it is the hemp rope arm restraint, this will return
@@ -388,6 +387,13 @@ declare function ExtendedItemGetDrawingOptions(item: Item): ExtendedItemOptionCo
  * @constant
  */
 declare var ExtendedItemOffsets: Record<string, number>;
+/**
+ * A set of properties to-be ignored by the `Init()` validation.
+ * This more relaxed validation is required as these properties can be fully configured by the user in one way or another
+ * and are thus not guaranteed to be linked to specific `TypeRecord` values
+ * @type {ReadonlySet<keyof ItemProperties>}
+ */
+declare const ExtendedItemInitPropertyIgnore: ReadonlySet<keyof ItemProperties>;
 /**
  * The X & Y co-ordinates of each option's button, based on the number to be displayed per page.
  * @type {[number, number][][]}

package/bc/Scripts/Game.d.ts

@@ -1,4 +1,8 @@
-declare function GameStart(): Promise<void>;
+/**
+ * Start BC after the webpage has fully loaded
+ * @param {boolean} isNode Whether BC is run through the browser or via Node (_i.e._ the testing suite)
+ */
+declare function GameStart(isNode?: boolean): Promise<void>;
 declare function GameHandleError(): void;
 /**
  * Periodically called in the background with low frequency, so the game doesn't freeze, even if the user switches to a different tab.

package/bc/Scripts/Item.d.ts

@@ -30,7 +30,7 @@ declare function ItemModuleVoiceCommandHandle(C: Character, item: Item, LastTime
  * @param {AssetGroupItemName[]} tamperZones
  */
 declare function ItemModulePunishCheck(C: Character, item: Item, shockCooldown: number, tamperZones: AssetGroupItemName[]): "Struggle" | "Orgasm" | "StandUp" | "StruggleOther" | null;
-declare namespace Item {
+declare namespace AppearanceItem {
     /**
      * Construct an item from the passed asset
      * @param {Asset} asset The asset in question

package/bc/Scripts/Layering.d.ts

@@ -1,50 +1,240 @@
-/**
- * Namespace with functions for managing the layering sub screen
- *
- * Below is an example of some basic usage of the {@link Layering} subscreen,
- * including a `Click` function for initializing the screen and a set of
- * `Resize` and `Exit` functions for, respectively, handling the screens
- * drawing/resizing and exiting
- *
- * @namespace
- * @example
- *
- * let FancyScreenMode: "default" | "layering" = "default";
- *
- * // Make sure the fancy screen mode is changed back to its default upon exiting the layering subscreen
- * Layering.RegisterExitCallbacks({
- *     screen: "FancyScreen",
- *     callback: () => FancyScreenMode = "default",
- * });
- *
- * function FancyScreenClick() {
- *     const C: Character;
- *     const item: Item;
- *     switch (FancyScreenMode) {
- *         case "default": {
- *             if Mousein(...) {
- *                 FancyScreenMode = "layering";
- *                 Layering.Init(C, item);
- *             }
- *             return;
- *         }
- *     }
- * }
- *
- * function FancyScreenResize(load) {
- *     switch (FancyScreenMode) {
- *         case "layering":
- *             Layering.Resize(load);
- *             return;
- *     }
- * }
- *
- * function FancyScreenExit() {
- *     switch (FancyScreenMode) {
- *         case "layering":
- *             Layering.Exit();
- *             return;
- *     }
- * }
- */
-declare var Layering: any;
+declare namespace Layering {
+    let PropertyNames: ReadonlySet<keyof ItemProperties>;
+    let Character: null | Character;
+    let activeTab: string;
+    let Display: null | LayeringDisplay;
+    let Item: null | Item;
+    let Readonly: boolean;
+    const Asset: Asset;
+    let OverridePriority: undefined | AssetLayerOverridePriority;
+    let _PriorityDefault: undefined | AssetLayerOverridePriority;
+    let _Readonly: boolean;
+    /**
+     * Update an item's property, optionally for a specific layer, and refresh the character.
+     * @param {Item} item - The item to update.
+     * @param {string} propName - The property name (e.g., "Rotation", "ScaleX").
+     * @param {any} value - The new value.
+     * @param {string} [layerName] - Optional layer name to update. If provided, updates layer-specific property.
+     */
+    function UpdateProperty(item: Item, propName: string, value: any, layerName?: string): void;
+    /**
+     * Return whether the layering sub screen has currently been initialized (be it either active or unloaded)
+     * @returns {this is Pick<Required<typeof Layering>, "Character" | "Display" | "Item">}
+     */
+    function IsActive(): this is Pick<Required<typeof Layering>, "Character" | "Display" | "Item">;
+    let DisplayDefault: Readonly<LayeringDisplay>;
+    let ID: Readonly<{
+        root: "layering";
+        resetButton: "layering-reset-button";
+        exitButton: "layering-exit-button";
+        hideButton: "layering-hide-button";
+        hideTooltip: "layering-hide-button-tooltip";
+        lockButton: "layering-lock-button";
+        assetHeader: "layering-asset-header";
+        assetGrid: "layering-asset-grid";
+        layerHeader: "layering-layer-header";
+        layerDIV: "layering-layer-div";
+        layerOuterGrid: "layering-layer-outer-grid";
+    }>;
+    let _ExitCallbacks: ((screen: string, C: Character, item: Item) => void)[];
+    /**
+     * private
+     * Initialize the object-based variant of {@link AssetLayerOverridePriority}
+     */
+    function _InitOverridePriorityObject(): void;
+    /**
+     * private
+     * @param {string} name - The name of the layer
+     * @param {number} priority - The stringified layer priority
+     * @param {string} defaultPriority - The stringified default priority of the layer
+     */
+    function _ApplyLayerPriority(name: string, priority: number, defaultPriority: string): void;
+    /**
+     * private
+     * @param {number} priority - The layer priority
+     * @param {string} defaultPriority - The stringified default priority of the layer
+     */
+    function _ApplyAssetPriority(priority: number, defaultPriority: string): void;
+    /**
+     * Event listener for `input` events involving layer priorities
+     * private
+     * @param {Event} event
+     */
+    function _LayerInputListener(event: Event): void;
+    /**
+     * Event listener for `input` events involving asset priorities
+     * private
+     * @param {Event} event
+     */
+    function _AssetInputListener(event: Event): void;
+    let _CharacterRefresh: (C: Character, Push?: boolean | undefined, RefreshDialog?: boolean | undefined) => void;
+    /**
+     * Event listener for `click` events of the reset button
+     * @this {HTMLButtonElement}
+     * @param {Event} _event
+     * private
+     */
+    function _ResetClickListener(this: HTMLButtonElement, _event: Event): void;
+    /**
+     * Event listener for `click` events of the show hidden layers button
+     * @this {HTMLButtonElement}
+     * @param {Event} _event
+     * private
+     */
+    function _ShowLayersClickListener(this: HTMLButtonElement, _event: Event): void;
+    /**
+     * Update the background colors of the `number`-based input elements, the color change depending on whether one is changing an asset- or layer-specific priority.
+     * private
+     * @param {"layer-priority" | "asset-priority"} activeType
+     */
+    function _UpdateInputColors(activeType: "layer-priority" | "asset-priority"): void;
+    let _inputCache: Record<string, HTMLInputElement[]>;
+    /**
+     * Updates the input validation limits for all relevant inputs based on the current combined values.
+     * private
+     */
+    function _UpdateLimits(): void;
+    /**
+     * private
+     * @param {string} propType
+     * @param {string[]} properties
+     * @param {number} min
+     * @param {number} max
+     * @param {number} step
+     * @param {number} defaultValue
+     * @param {Record<string, [number, number]>} [constraints={}]
+     * @returns {Element[]}
+     */
+    function _CreateTabContent(propType: string, properties: string[], min: number, max: number, step: number, defaultValue: number, isShowingHiddenLayers: any, constraints?: Record<string, [number, number]>): Element[];
+    /**
+     * private
+     * @param {AssetLayer} layer
+     * @param {string[]} properties
+     * @param {number} min
+     * @param {number} max
+     * @param {number} step
+     * @param {number} defaultValue
+     * @param {boolean} isShowingHiddenLayers
+     * @param {Record<string, [number, number]>} constraints
+     */
+    function _CreateLayerFieldset(layer: AssetLayer, propType: any, properties: string[], min: number, max: number, step: number, defaultValue: number, isShowingHiddenLayers: boolean, constraints: Record<string, [number, number]>): {
+        tag: string;
+        classList: string[];
+        attributes: {
+            hidden: boolean;
+        };
+        children: {
+            tag: string;
+            classList: string[];
+            children: ({
+                tag: string;
+                classList: string[];
+                children: string[];
+            } | {
+                tag: string;
+                classList: string[];
+                children: {
+                    tag: string;
+                    classList: string[];
+                    children: ({
+                        tag: string;
+                        attributes: {
+                            type: string;
+                            value: any;
+                            step: number;
+                            min: number;
+                            max: number;
+                            id: string;
+                            class: string;
+                            inputmode: string;
+                        };
+                        eventListeners: {
+                            input: (event: Event) => void;
+                        };
+                    } | {
+                        tag: string;
+                        children: string[];
+                        attributes: {
+                            for: string;
+                        };
+                    })[];
+                }[];
+            })[];
+        }[];
+    };
+    /**
+     * private
+     * @param {AssetGroup} group
+     * @returns {boolean}
+     */
+    function _IsBlacklisted(group: AssetGroup): boolean;
+    /**
+     * private
+     * @param {AssetGroup} group
+     * @returns {boolean}
+     */
+    function _IsPussy(group: AssetGroup): boolean;
+    /**
+     * private
+     * @param {string} tabKey
+     * @returns {Element[]}
+     */
+    function _GetTabContents(tabKey: string): Element[];
+    /**
+     * Helper to build priority fieldset to avoid repetition
+     * private
+     */
+    function _BuildLayerPriorityFieldset(isShowingHiddenLayers: any): HTMLFieldSetElement;
+    /**
+     * Group all layers by their {@link AssetLayer.CopyLayerColor} properties
+     * private
+     * @param {readonly AssetLayer[]} layers
+     * @returns {Record<string, AssetLayer[]>}
+     */
+    function _GroupLayers(layers: readonly AssetLayer[]): Record<string, AssetLayer[]>;
+    /**
+     * Return the default `Property.OverridePriority` of the current item.
+     *
+     * This is generally `undefined`, though certain extended item options do overwrite it.
+     * private
+     * @returns {undefined | AssetLayerOverridePriority}
+     */
+    function _GetDefaultPriority(): undefined | AssetLayerOverridePriority;
+    /**
+     * Update all input elements and buttons with the passed {@link Layering.Readonly} status.
+     * @param {boolean} isReadonly
+     * private
+     */
+    function _ApplyReadonly(isReadonly: boolean): void;
+    /**
+     * Initialize the layering subscreen
+     * @param {Item} item - The affected item
+     * @param {Character} character - The item's owning character
+     * @param {null | Partial<LayeringDisplay>} display - The shape of the layering subscreen
+     * @param {boolean} reload - Whether we're loading or reloading the screen.
+     * A reload pushes any current changes towards the server and reinitializes all DOM elements.
+     * @returns {Promise<HTMLDivElement>} The div containing the layering subscreen
+     */
+    function Init(item: Item, character: Character, display?: null | Partial<LayeringDisplay>, reload?: boolean, readonly?: boolean): Promise<HTMLDivElement>;
+    /**
+     * Apply translation to the layering screen
+     * private
+     */
+    function _ApplyTranslations(): void;
+    function Load(): Promise<void>;
+    function Resize(load: boolean): void;
+    function Unload(): void;
+    /**
+     * @satisfies {ScreenExitHandler}
+     * @param {boolean} reload - Whether the exit call is part of a reload (see {@link Layering.Init})
+     */
+    function Exit(reload?: boolean): void;
+    /**
+     * Register screen-specific callbacks to-be executed after calling {@link Layering.Exit}.
+     *
+     * Callbacks registered herein must be used _exclusively_ for setting up the next screen, and not for tearing down the layering sub screen.
+     * As such, they are ignored when performing a reload of the layering sub screen (see {@link Layering.Init})
+     * @param {readonly LayeringExitOptions[]} options
+     */
+    function RegisterExitCallbacks(...options: readonly LayeringExitOptions[]): void;
+}

package/bc/Scripts/TypedItem.d.ts

@@ -119,10 +119,9 @@ declare function TypedItemGetOption(groupName: AssetGroupName, assetName: string
  * @param {T} previousOption - The previously applied option
  * @param {boolean} [permitExisting] - Determines whether the validation should allow the new option and previous option
  * to be identical. Defaults to false.
- * @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.
+ * @returns {string|null} - Returns a string message informing the player of the requirements that are not met, null otherwise.
  */
-declare function TypedItemValidateOption<T extends ExtendedItemOption>(data: null | ExtendedItemData<T>, C: Character, item: Item, option: T, previousOption: T, permitExisting?: boolean): string | undefined;
+declare function TypedItemValidateOption<T extends ExtendedItemOption>(data: null | ExtendedItemData<T>, C: Character, item: Item, option: T, previousOption: T, permitExisting?: boolean): string | null;
 /**
  * Sets a typed item's type and properties to the option whose name matches the provided option name parameter.
  * @param {Character} C - The character on whom the item is equipped

package/bc/Scripts/VibratorMode.d.ts

@@ -52,10 +52,9 @@ declare function VibratorModeGetOptions(data: VibratingItemData, modeSet: readon
  * @param {VibratingItemOption} previousOption - The previously applied option
  * @param {boolean} permitExisting - Determines whether the validation should allow the new option and previous option
  * to be identical. Defaults to `false`.
- * @returns {string} - undefined or an empty string if the validation passes. Otherwise, returns a string
- * message informing the player of the requirements that are not met.
+ * @returns {string | null} - Returns a string message informing the player of the requirements that are not met, null otherwise.
  */
-declare function VibratorModeValidate(data: VibratingItemData, C: Character, item: Item, newOption: VibratingItemOption, previousOption: VibratingItemOption, permitExisting?: boolean): string;
+declare function VibratorModeValidate(data: VibratingItemData, C: Character, item: Item, newOption: VibratingItemOption, previousOption: VibratingItemOption, permitExisting?: boolean): string | null;
 /**
  * Publish a vibrator action and exit the dialog of applicable
  * @param {VibratingItemData} data

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bc-stubs",
-  "version": "131.0.0-Alpha.1",
+  "version": "131.0.0-Beta.2",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/bananarama92/BC-stubs.git"