bc-stubs 96.0.0

package/bc/Scripts/Character.d.ts

@@ -0,0 +1,495 @@
+/**
+ * Loads a character into the buffer, creates it if it does not exist
+ * @param {number} CharacterID - ID of the character
+ * @param {IAssetFamily} CharacterAssetFamily - Name of the asset family of the character
+ * @param {CharacterType} [Type=CharacterType.ONLINE] - The character type
+ * @returns {Character} - The newly loaded character
+ */
+declare function CharacterReset(CharacterID: number, CharacterAssetFamily: IAssetFamily, Type?: CharacterType): Character;
+/**
+ * Attributes a random name for the character, does not select a name in use
+ * @param {Character} C - Character for which to attribute a name
+ * @returns {void} - Nothing
+ */
+declare function CharacterRandomName(C: Character): void;
+/**
+ * Substitute name and pronoun fields in dialog.
+ * @param {Character} C - Character for which to build the dialog
+ * @returns {void} - Nothing
+ */
+declare function CharacterDialogSubstitution(C: Character): void;
+/**
+ * Builds the dialog objects from the character CSV file
+ * @param {Character} C - Character for which to build the dialog
+ * @param {readonly string[][]} CSV - Content of the CSV file
+ * @param {string} functionPrefix - A prefix that will be added to functions that aren't part of the Dialog or ChatRoom "namespace"
+ * @returns {void} - Nothing
+ */
+declare function CharacterBuildDialog(C: Character, CSV: readonly string[][], functionPrefix: string): void;
+/**
+ * Loads the content of a CSV file to build the character dialog. Can override the current screen.
+ * @param {Character} C - Character for which to build the dialog objects
+ * @param {DialogInfo} [info]
+ * @returns {void} - Nothing
+ */
+declare function CharacterLoadCSVDialog(C: Character, info?: DialogInfo): void;
+/**
+ * Sets the clothes based on a character archetype
+ * @param {Character} C - Character to set the clothes for
+ * @param {"Maid" | "Mistress" | "Employee"} Archetype - Archetype to determine the clothes to put on
+ * @param {string} [ForceColor] - Color to use for the added clothes
+ * @returns {void} - Nothing
+ */
+declare function CharacterArchetypeClothes(C: Character, Archetype: "Maid" | "Mistress" | "Employee", ForceColor?: string): void;
+/**
+ * Loads an NPC into the character array. The appearance is randomized, and a type can be provided to dress them in a given style.
+ * @param {string} NPCType - Archetype of the NPC
+ * @returns {NPCCharacter} - The randomly generated NPC
+ */
+declare function CharacterLoadNPC(NPCType: string): NPCCharacter;
+/**
+ * Create a minimal character object
+ * @param {string} AccName - The account name to give to the character
+ * @returns {Character} - The created character
+ */
+declare function CharacterLoadSimple(AccName: string): Character;
+/**
+ * Sets up an online character
+ * @param {Character} Char - Online character to set up
+ * @param {object} data - Character data received
+ * @param {number} SourceMemberNumber - Source number of the refresh
+ */
+declare function CharacterOnlineRefresh(Char: Character, data: object, SourceMemberNumber: number): void;
+/**
+ * Loads an online character and flags it for a refresh if any data was changed
+ * @param {object} data - Character data received
+ * @param {number} SourceMemberNumber - Source number of the load trigger
+ * @returns {Character} - The reloaded character
+ */
+declare function CharacterLoadOnline(data: object, SourceMemberNumber: number): Character;
+/**
+ * Deletes an NPC from the buffer
+ * @param {string} NPCType - Account name of the npc to delete
+ * @returns {void} - Nothing
+ */
+declare function CharacterDelete(NPCType: string): void;
+/**
+ * Deletes all online characters from the character array
+ * @returns {void} - Nothing
+ */
+declare function CharacterDeleteAllOnline(): void;
+/**
+ * Checks whether the given character can change to the named pose unaided
+ * @param {Character} C - The character to check
+ * @param {AssetPoseName} poseName - The name of the pose to check for
+ * @returns {boolean} - Returns true if the character has no conflicting items and is not prevented from changing to
+ * the provided pose
+ */
+declare function CharacterCanChangeToPose(C: Character, poseName: AssetPoseName): boolean;
+/**
+ * Checks if a certain pose is whitelisted and available for the pose menu
+ * @param {Character} C - Character to check for the pose
+ * @param {AssetPoseCategory|undefined} Type - Pose type to check for within items
+ * @param {AssetPoseName} Pose - Pose to check for whitelist
+ * @returns {boolean} - TRUE if the character has the pose available
+ */
+declare function CharacterItemsHavePoseAvailable(C: Character, Type: AssetPoseCategory | undefined, Pose: AssetPoseName): boolean;
+/**
+ * Checks if a character has a pose from items (not active pose unless an item lets it through)
+ * @param {Character} C - Character to check for the pose
+ * @param {AssetPoseName} Pose - Pose to check for within items
+ * @param {boolean} [ExcludeClothes=false] - Ignore clothing items in the check
+ * @returns {boolean} - TRUE if the character has the pose
+ */
+declare function CharacterItemsHavePose(C: Character, Pose: AssetPoseName, ExcludeClothes?: boolean): boolean;
+/**
+ * Checks whether the items on a character set a given pose on the character
+ * @param {Character} C - The character to check
+ * @param {AssetPoseName} pose - The name of the pose to check for
+ * @param {boolean} [excludeClothes=false] - Ignore clothing items in the check
+ * @returns {boolean} - Returns true if the character is wearing an item that sets the given pose, false otherwise
+ */
+declare function CharacterDoItemsSetPose(C: Character, pose: AssetPoseName, excludeClothes?: boolean): boolean;
+/**
+ * Checks if a character has a pose type from items (not active pose unless an item lets it through)
+ * @param {Character} C - Character to check for the pose type
+ * @param {string} Type - Pose type to check for within items
+ * @param {boolean} OnlyItems - Whether or not allowed activeposes should be ignored.
+ * @returns {boolean} - TRUE if the character has the pose type active
+ */
+declare function CharacterItemsHavePoseType(C: Character, Type: string, OnlyItems: boolean): boolean;
+/**
+ * Refreshes the list of poses for a character. Each pose can only be found once in the pose array
+ * @param {Character} C - Character for which to refresh the pose list
+ * @returns {void} - Nothing
+ */
+declare function CharacterLoadPose(C: Character): void;
+/**
+ * Refreshes the list of effects for a character. Each effect can only be found once in the effect array
+ * @param {Character} C - Character for which to refresh the effect list
+ * @returns {void} - Nothing
+ */
+declare function CharacterLoadEffect(C: Character): void;
+/**
+ * Refreshes the character's attribute list
+ * @param {Character} C
+ * @returns {void} - Nothing
+ */
+declare function CharacterLoadAttributes(C: Character): void;
+/**
+ * Returns a list of effects for a character from some or all groups
+ * @param {Character} C - The character to check
+ * @param {readonly AssetGroupName[]} [Groups=null] - Optional: The list of groups to consider. If none defined, check all groups
+ * @param {boolean} [AllowDuplicates=false] - Optional: If true, keep duplicates of the same effect provided they're taken from different groups
+ * @returns {EffectName[]} - A list of effects
+ */
+declare function CharacterGetEffects(C: Character, Groups?: readonly AssetGroupName[], AllowDuplicates?: boolean): EffectName[];
+/**
+ * Loads a character's tints, resolving tint definitions against items from the character's appearance
+ * @param {Character} C - Character whose tints should be loaded
+ * @returns {void} - Nothing
+ */
+declare function CharacterLoadTints(C: Character): void;
+/**
+ * Loads a character's canvas by sorting its appearance and drawing it.
+ * @param {Character} C - Character to load the canvas for
+ * @returns {void} - Nothing
+ */
+declare function CharacterLoadCanvas(C: Character): void;
+/**
+ * Reloads all character canvases in need of being redrawn.
+ * @returns {void} - Nothing
+ */
+declare function CharacterLoadCanvasAll(): void;
+/**
+ * Sets the current character to have a dialog with
+ * @param {Character} C - Character to have a conversation with
+ * @returns {void} - Nothing
+ */
+declare function CharacterSetCurrent(C: Character): void;
+/**
+ * Changes the character money and sync with the account server, factors in the cheaters version.
+ * @param {Character} C - Character for which we are altering the money amount
+ * @param {number} Value - Money to subtract/add
+ * @returns {void} - Nothing
+ */
+declare function CharacterChangeMoney(C: Character, Value: number): void;
+/**
+ * Refreshes the character parameters (Effects, poses, canvas, settings, etc.)
+ * @param {Character} C - Character to refresh
+ * @param {boolean} [Push=true] - Pushes the data to the server if true or null
+ * @param {boolean} [RefreshDialog=true] - Refreshes the character dialog
+ * @returns {void} - Nothing
+ */
+declare function CharacterRefresh(C: Character, Push?: boolean, RefreshDialog?: boolean): void;
+/**
+ * Refresh the character's dialog state.
+ *
+ * This function restore consistency between its state variables and the new character appearance,
+ * like making sure the focused items are still present and deselecting them otherwise.
+ *
+ * @param {Character} C - Character to refresh
+ * @returns {void} - Nothing
+ */
+declare function CharacterRefreshDialog(C: Character): void;
+/**
+ * Checks if a character is wearing items (restraints), the slave collar is ignored.
+ * @param {Character} C - Character to inspect the appearance of
+ * @returns {boolean} - Returns TRUE if the given character is wearing an item
+ */
+declare function CharacterHasNoItem(C: Character): boolean;
+/**
+ * Checks if a character is naked
+ * @param {Character} C - Character to inspect the appearance of
+ * @returns {boolean} - Returns TRUE if the given character is naked
+ */
+declare function CharacterIsNaked(C: Character): boolean;
+/**
+ * Checks if a character is in underwear
+ * @param {Character} C - Character to inspect the appearance of
+ * @returns {boolean} - Returns TRUE if the given character is at most in underwear (can be naked)
+ */
+declare function CharacterIsInUnderwear(C: Character): boolean;
+/**
+ * Removes all appearance items from the character
+ * @param {Character} C - Character to undress
+ * @returns {void} - Nothing
+ */
+declare function CharacterNaked(C: Character): void;
+/**
+ * Dresses the given character in random underwear
+ * @param {Character} C - Character to randomly dress
+ * @returns {void} - Nothing
+ */
+declare function CharacterRandomUnderwear(C: Character): void;
+/**
+ * Removes all appearance items from the character except underwear
+ * @param {Character} C - Character to undress partially
+ * @param {Array.<*>} Appearance - Appearance array to remove clothes from
+ * @returns {void} - Nothing
+ */
+declare function CharacterUnderwear(C: Character, Appearance: Array<any>): void;
+/**
+ * Redresses a character based on a given appearance array
+ * @param {Character} C - Character to redress
+ * @param {Array.<*>} Appearance - Appearance array to redress the character with
+ * @returns {void} - Nothing
+ */
+declare function CharacterDress(C: Character, Appearance: Array<any>): void;
+/**
+ * Removes all binding items from a given character
+ * @param {Character} C - Character to release
+ * @param {boolean} [Refresh=false] - do not call CharacterRefresh if false
+ * @returns {void} - Nothing
+ */
+declare function CharacterRelease(C: Character, Refresh?: boolean): void;
+/**
+ * Releases a character from all locks matching the given lock name
+ * @param {Character} C - Character to release from the lock(s)
+ * @param {AssetLockType} LockName - Name of the lock to look for
+ * @returns {void} - Nothing
+ */
+declare function CharacterReleaseFromLock(C: Character, LockName: AssetLockType): void;
+/**
+ * Releases a character from all restraints that are not locked
+ * @param {Character} C - Character to release
+ * @returns {void} - Nothing
+ */
+declare function CharacterReleaseNoLock(C: Character): void;
+/**
+ * Removes all items except for clothing and slave collars from the character
+ * @param {Character} C - Character to release
+ * @returns {void} - Nothing
+ */
+declare function CharacterReleaseTotal(C: Character): void;
+/**
+ * Gets the bonus amount of a given type for a given character (Kidnap league)
+ * @param {Character} C - Character for which we want to get the bonus amount
+ * @param {string} BonusType - Type/name of the bonus to look for
+ * @returns {number} - Active bonus amount for the bonus type
+ */
+declare function CharacterGetBonus(C: Character, BonusType: string): number;
+/**
+ * Restrains a character with random restraints. Some restraints are specifically disabled for randomization in their definition.
+ * @param {Character} C - The target character to restrain
+ * @param {"FEW"|"LOT"|"ALL"} [Ratio] - Amount of restraints to put on the character
+ * @param {boolean} [Refresh] - do not call CharacterRefresh if false
+ */
+declare function CharacterFullRandomRestrain(C: Character, Ratio?: "FEW" | "LOT" | "ALL", Refresh?: boolean): void;
+/**
+ * Sets a new pose for the character
+ * @param {Character} C - Character for which to set the pose
+ * @param {null | AssetPoseName} NewPose - Name of the pose to set as active or `null` to return to the default pose
+ * @param {boolean} [ForceChange=false] - TRUE if the set pose(s) should overwrite current active pose(s)
+ * @returns {void} - Nothing
+ */
+declare function CharacterSetActivePose(C: Character, NewPose: null | AssetPoseName, ForceChange?: boolean): void;
+/**
+ * Sets a specific facial expression on the character's specified AssetGroup.
+ *
+ * If there's a timer, the expression will expire after it. Note that a timed expression cannot override another one.
+ *
+ * Be careful that "Eyes" for this function means both eyes. Use Eyes1/Eyes2 to target the left or right one only.
+ *
+ * @param {Character} C - Character for which to set the expression of
+ * @param {AssetGroupBodyName | "Eyes1"} AssetGroup - Asset group for the expression
+ * @param {null | ExpressionName} Expression - Name of the expression to use
+ * @param {number} [Timer] - Optional: time the expression will last
+ * @param {string|string[]} [Color] - Optional: color of the expression to set
+ * @returns {void} - Nothing
+ */
+declare function CharacterSetFacialExpression(C: Character, AssetGroup: AssetGroupBodyName | "Eyes1", Expression: null | ExpressionName, Timer?: number, Color?: string | string[], fromQueue?: boolean): void;
+/**
+ * Resets the character's facial expression to the default
+ * @param {Character} C - Character for which to reset the expression of
+ * @returns {void} - Nothing
+ */
+declare function CharacterResetFacialExpression(C: Character): void;
+/**
+ * Checks if a given expression is allowed on a character
+ * @param {Character} C
+ * @param {Item} Item
+ * @param {ExpressionName} Expression
+ */
+declare function CharacterIsExpressionAllowed(C: Character, Item: Item, Expression: ExpressionName): boolean;
+/**
+ * Gets the currently selected character
+ * @returns {Character|null} - Currently selected character
+ */
+declare function CharacterGetCurrent(): Character | null;
+/**
+ * Compresses a character wardrobe from an array to a LZ string to use less storage space
+ * @param {Array.<Array.<*>>} Wardrobe - Uncompressed wardrobe
+ * @returns {string} - The compressed wardrobe
+ */
+declare function CharacterCompressWardrobe(Wardrobe: Array<Array<any>>): string;
+/**
+ * Decompresses a character wardrobe from a LZ String to an array if it was previously compressed (For backward compatibility with old
+ * wardrobes)
+ * @param {Array.<Array.<*>> | string} Wardrobe - The current wardrobe
+ * @returns {Array.<Array.<*>>} - The array of wardrobe items decompressed
+ */
+declare function CharacterDecompressWardrobe(Wardrobe: Array<Array<any>> | string): Array<Array<any>>;
+/**
+ * Checks if the character is wearing an item that has a specific attribute
+ * @param {Character} C - The character to test for
+ * @param {AssetAttribute} Attribute - The name of the attribute that must be allowed
+ * @returns {boolean} - TRUE if at least one item has that attribute
+ */
+declare function CharacterHasItemWithAttribute(C: Character, Attribute: AssetAttribute): boolean;
+/**
+ * Checks if the character is wearing an item that allows for a specific activity
+ * @param {Character} C - The character to test for
+ * @param {ActivityName} Activity - The name of the activity that must be allowed
+ * @returns {Item[]} - A list of items allowing that activity
+ */
+declare function CharacterItemsForActivity(C: Character, Activity: ActivityName): Item[];
+/**
+ * Checks if the character is wearing an item that allows for a specific activity
+ * @param {Character} C - The character to test for
+ * @param {ActivityName} Activity - The name of the activity that must be allowed
+ * @returns {boolean} - TRUE if at least one item allows that activity
+ */
+declare function CharacterHasItemForActivity(C: Character, Activity: ActivityName): boolean;
+/**
+ * Checks if the character is edged or not. The character is edged if every equipped vibrating item on an orgasm zone has the "Edged" effect
+ * @param {Character} C - The character to check
+ * @returns {boolean} - TRUE if the character is edged, FALSE otherwise
+ */
+declare function CharacterIsEdged(C: Character): boolean;
+/**
+ * Checks if the character is wearing an item flagged as a category in a blocked list
+ * @param {Character} C - The character to validate
+ * @param {Array} BlockList - An array of strings to validate
+ * @returns {boolean} - TRUE if the character is wearing a blocked item, FALSE otherwise
+ */
+declare function CharacterHasBlockedItem(C: Character, BlockList: any[]): boolean;
+/**
+ * Retrieves the member numbers of the given character
+ * @param {Character} C - The character to retrieve the lovers numbers from
+ * @param {Boolean} [MembersOnly] - Whether to omit NPC lovers - defaults to false (NPCs will be included by default)
+ * @returns {Array<String | Number>} - A list of member numbers or NPC account names representing the lovers of the
+ * given character
+ */
+declare function CharacterGetLoversNumbers(C: Character, MembersOnly?: boolean): Array<string | number>;
+/**
+ * Returns whether the character appears upside-down on the screen which may depend on the player's own inverted status
+ * @param {Character} C - The character to check
+ * @returns {boolean} - If TRUE, the character appears upside-down
+ */
+declare function CharacterAppearsInverted(C: Character): boolean;
+/**
+ * Checks whether the given character can kneel unaided
+ * @param {Character} C - The character to check
+ * @returns {boolean} - Returns true if the character is capable of kneeling unaided, false otherwise
+ */
+declare function CharacterCanKneel(C: Character): boolean;
+/**
+ * Determines how much the character's view should be darkened based on their blind level. 1 is fully visible, 0 is pitch black.
+ * @param {Character} C - The character to check
+ * @param {boolean} [eyesOnly=false] - If TRUE only check whether the character has eyes closed, and ignore item effects
+ * @returns {number} - The number between 0 (dark) and 1 (bright) that determines screen darkness
+ */
+declare function CharacterGetDarkFactor(C: Character, eyesOnly?: boolean): number;
+/**
+ * Gets the array of color tints that should be applied for a character in RGBA format.
+ * @param {Character} C - The character
+ * @returns {RGBAColor[]} - A list of RGBA tints that are currently affecting the character
+ */
+declare function CharacterGetTints(C: Character): RGBAColor[];
+/**
+ * Gets the clumsiness level of a character. This represents dexterity when interacting with locks etc. and can have a
+ * maximum value of 5.
+ * @param {Character} C - The character to check
+ * @returns {number} - The clumsiness rating of the player, a number between 0 and 5 inclusive.
+ */
+declare function CharacterGetClumsiness(C: Character): number;
+/**
+ * Applies hooks to a character based on conditions
+ * Future hooks go here
+ * @param {Character} C - The character to check
+ * @param {boolean} IgnoreHooks - Whether to remove some hooks from the player (such as during character dialog).
+ * @returns {boolean} - If a hook was applied or removed
+ */
+declare function CharacterCheckHooks(C: Character, IgnoreHooks: boolean): boolean;
+/**
+ * Transfers an item from one character to another
+ * @param {Character} FromC - The character from which to pick the item
+ * @param {Character} ToC - The character on which we must put the item
+ * @param {AssetGroupName} Group - The item group to transfer (Cloth, Hat, etc.)
+ * @returns {void} - Nothing
+ */
+declare function CharacterTransferItem(FromC: Character, ToC: Character, Group: AssetGroupName, Refresh: any): void;
+/**
+ * Check if the given character can be aroused at all.
+ * @param {Character} C - The character to test
+ * @returns {boolean} That character can be aroused
+ */
+declare function CharacterHasArousalEnabled(C: Character): boolean;
+/**
+ * Removes all ownership and owner-only data
+ * @param {Character} C - The character breaking from their owner
+ * @returns {void} - Nothing.
+ */
+declare function CharacterClearOwnership(C: Character): void;
+/**
+ * Returns the nickname of a character, or the name if the nickname isn't valid
+ * Also validates if the character is a GGTS drone to alter her name
+ * @param {Character} C - The character breaking from their owner
+ * @returns {string} - The nickname to return
+ */
+declare function CharacterNickname(C: Character): string;
+/**
+ * Returns dialog text for a character based on their chosen pronouns. Default to She/Her entries
+ * @param {Character} C - The character to fetch dialog for
+ * @param {string} DialogKey - The type of dialog entry to look for
+ * @param {boolean} HideIdentity - Whether to use generic they/them pronouns
+ * @returns {string} - The text to use
+ */
+declare function CharacterPronoun(C: Character, DialogKey: string, HideIdentity: boolean): string;
+/**
+ * Returns the description text for the character's chosen pronouns. Default to She/Her
+ * @param {Character} C - The character to fetch text for
+ * @returns {string} - The text to use
+ */
+declare function CharacterPronounDescription(C: Character): string;
+declare function CharacterSetNickname(C: any, Nick: any): "NicknameTooLong" | "NicknameInvalidChars";
+/**
+ * Updates the leash state on a character
+ *
+ * @param {Character} C
+ */
+declare function CharacterRefreshLeash(C: Character): void;
+/**
+ * Create and return a character's script item, if appropriate
+ * @param {Character} C
+ * @returns {Item}
+ */
+declare function CharacterScriptGet(C: Character): Item;
+/**
+ * Refresh the character's script
+ * @param {Character} C
+ */
+declare function CharacterScriptRefresh(C: Character): void;
+/**
+ * Remove a character's script item
+ * @param {Character} C
+ */
+declare function CharacterScriptRemove(C: Character): void;
+/** @type Character[] */
+declare var Character: Character[];
+declare var CharacterNextId: number;
+/** @type {Map<BlindEffectName, number>} */
+declare const CharacterBlindLevels: Map<BlindEffectName, number>;
+/** @type {Map<DeafEffectName, number>} */
+declare const CharacterDeafLevels: Map<DeafEffectName, number>;
+/** @type {Map<BlurEffectName, number>} */
+declare const CharacterBlurLevels: Map<BlurEffectName, number>;
+/**
+ * An enum representing the various character archetypes
+ * ONLINE: The player, or a character representing another online player
+ * NPC: Any NPC
+ * SIMPLE: Any simple character, generally used internally and not to represent an actual in-game character
+ * @type {Record<"ONLINE"|"NPC"|"SIMPLE", CharacterType>}
+ */
+declare var CharacterType: Record<"ONLINE" | "NPC" | "SIMPLE", CharacterType>;

package/bc/Scripts/CharacterName.d.ts

@@ -0,0 +1 @@
+declare var CharacterName: string[];

package/bc/Scripts/ColorPicker.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Attaches event listeners required for the color picker to the canvas
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerAttachEventListener(): void;
+/**
+ * Removes the color picker related event listeners from the canvas
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerRemoveEventListener(): void;
+/**
+ * Helper to guard for TouchEvents
+ * @param {Event} event
+ * @returns {event is TouchEvent}
+ */
+declare function isTouchEvent(event: Event): event is TouchEvent;
+/**
+ * When the touch/mouse event begins to be registered. On mobile we only fire it once
+ * @param {MouseEvent|TouchEvent} Event - The touch/mouse event
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerStartPick(Event: MouseEvent | TouchEvent): void;
+/**
+ * When we stop registering the touch/mouse event, to remove the attached event listeners
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerEndPick(): void;
+/**
+ * Gets the coordinates of the current event on the canvas
+ * @param {MouseEvent|TouchEvent} Event - The touch/mouse event
+ * @returns {{X: number, Y: number}} - Coordinates of the click/touch event on the canvas
+ */
+declare function ColorPickerGetCoordinates(Event: MouseEvent | TouchEvent): {
+    X: number;
+    Y: number;
+};
+/**
+ * Sets the picked hue based on the Event coordinates on the canvas
+ * @param {MouseEvent|TouchEvent} Event - The touch/mouse event
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerPickHue(Event: MouseEvent | TouchEvent): void;
+/**
+ * Sets the picked saturation (SV) based on the Event coordinates on the canvas
+ * @param {MouseEvent|TouchEvent} Event - The touch/mouse event
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerPickSV(Event: MouseEvent | TouchEvent): void;
+/**
+ * Sets the picked HSV from the color palette
+ * @param {MouseEvent|TouchEvent} Event - The touch/mouse event
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerSelectFromPalette(Event: MouseEvent | TouchEvent): void;
+/**
+ * Handles clicking on the favorite colors palette
+ * @param {MouseEvent|TouchEvent} Event - The touch/mouse event
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerSelectFromFavorites(Event: MouseEvent | TouchEvent): void;
+/**
+ * Handles the previous, next, and save button functionality for the color picker.
+ * @param {MouseEvent|TouchEvent} Event - The touch/mouse event
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerSelectButton(Event: MouseEvent | TouchEvent): void;
+/**
+ * Alters the color picker display based on the selected value
+ * @param {boolean} [sourceElementChanged=false] - True if the color was updated by the text input element
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerNotify(sourceElementChanged?: boolean): void;
+/**
+ * Removes the color picker and its listeners from the canvas
+ * @return {void} - Nothing
+ */
+declare function ColorPickerHide(): void;
+/**
+ * Checks if two hex color codes are equal, will convert short hand hex codes (#FFF is equal to #FFFFFF)
+ * @param {HexColor} Color1 - First color to compare
+ * @param {HexColor} Color2 - Second color to compare
+ * @returns {boolean} - Returns TRUE if the two colors are the same
+ */
+declare function ColorPickerCSSColorEquals(Color1: HexColor, Color2: HexColor): boolean;
+/**
+ * Draws the color picker on the canvas
+ * @param {number} X - Coordinate on the X axis
+ * @param {number} Y - Coordinate on the Y axis
+ * @param {number} Width - Width of the color picker
+ * @param {number} Height - Height of the color picker
+ * @param {HTMLInputElement} Src - Input element that can contain a hex color code
+ * @param {ColorPickerCallbackType} [Callback] - Callback to execute when the selected color changes
+ * @returns {void} - Nothing
+ */
+declare function ColorPickerDraw(X: number, Y: number, Width: number, Height: number, Src: HTMLInputElement, Callback?: ColorPickerCallbackType): void;
+/**
+ * Parses a hex color code and converts it to a HSV object
+ * @param {HexColor} Color - Hex color code
+ * @param {HSVColor} [DefaultHSV] - The HSV to output if the color is not valid
+ * @returns {HSVColor} - The HSV color from a hex color code
+ * @see {@link https://gist.github.com/mjackson/5311256}
+ */
+declare function ColorPickerCSSToHSV(Color: HexColor, DefaultHSV?: HSVColor): HSVColor;
+/**
+ * Converts a HSV object into a valid hex code to use in the css
+ * @param {HSVColor} HSV - HSV value to convert
+ * @returns {HexColor} - Hex color code corresponding to the given HSV
+ */
+declare function ColorPickerHSVToCSS(HSV: HSVColor): HexColor;
+/**
+ * Returns the array of default colors for the list of favorite colors.
+ * @returns {HSVColor[]} - Array of default colors
+ */
+declare function GetDefaultSavedColors(): HSVColor[];
+declare var ColorPickerX: number;
+declare var ColorPickerY: number;
+declare var ColorPickerWidth: number;
+declare var ColorPickerHeight: number;
+declare var ColorPickerInitialHSV: HSVColor;
+declare var ColorPickerLastHSV: HSVColor;
+declare var ColorPickerHSV: HSVColor;
+/** @type {HTMLInputElement} */
+declare var ColorPickerSourceElement: HTMLInputElement;
+/** @type {ColorPickerCallbackType} */
+declare let ColorPickerCallback: ColorPickerCallbackType;
+/** @type {string} */
+declare var ColorPickerCSS: string;
+/** @type {boolean} */
+declare var ColorPickerIsDefault: boolean;
+/** @type {null | number} */
+declare var ColorPickerSelectedFavoriteIndex: null | number;
+declare var ColorPickerFavoritesPage: number;
+/** @type {HSVColor[]} */
+declare var DefaultSavedColors: HSVColor[];
+declare var ColorPickerHueBarHeight: number;
+declare var ColorPickerSVPanelGap: number;
+declare var ColorPickerPaletteHeight: number;
+declare var ColorPickerPaletteGap: number;
+declare var ColorPickerFavoritesPaletteHeight: number;
+declare var ColorPickerFavoritesPaletteGap: number;
+declare namespace ColorPickerLayout {
+    const HueBarOffset: number;
+    const HueBarHeight: number;
+    const SVPanelOffset: number;
+    const SVPanelHeight: number;
+    const PaletteOffset: number;
+    const PaletteHeight: number;
+    const FavoritesPaletteOffset: number;
+    const FavoritesPaletteHeight: number;
+    const ButtonOffset: number;
+    const NextButtonX: number;
+    const SaveButtonX: number;
+    const PrevButtonX: number;
+}
+declare const ColorPickerNumSaved: 18;