bc-stubs 96.0.0

package/bc/Scripts/TextItem.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Registers a typed extended item. This automatically creates the item's load, draw and click functions. It will also
+ * generate the asset's AllowType array.
+ * @param {Asset} asset - The asset being registered
+ * @param {TextItemConfig} config - The item's typed item configuration
+ * @param {null | ExtendedItemOption} parentOption
+ * @param {boolean} createCallbacks - Whether the archetype-specific callbacks should be created or not
+ * @returns {TextItemData} - The generated extended item data for the asset
+ */
+declare function TextItemRegister(asset: Asset, config: TextItemConfig, parentOption?: null | ExtendedItemOption, createCallbacks?: boolean): TextItemData;
+/**
+ * Parse the passed text item draw data as passed via the extended item config
+ * @param {readonly TextItemNames[]} fieldNames
+ * @param {ExtendedItemConfigDrawData<{}> | undefined} drawData - The to-be parsed draw data
+ * @return {ExtendedItemDrawData<ElementMetaData.Text>} - The parsed draw data
+ */
+declare function TextItemGetDrawData(fieldNames: readonly TextItemNames[], drawData: ExtendedItemConfigDrawData<{}> | undefined): ExtendedItemDrawData<ElementMetaData.Text>;
+/**
+ * Generates an asset's typed item data
+ * @param {Asset} asset - The asset to generate modular item data for
+ * @param {TextItemConfig} config - The item's extended item configuration
+ * @param {null | ExtendedItemOption} parentOption - The parent extended item option of the super screens (if any)
+ * @returns {TextItemData} - The generated typed item data for the asset
+ */
+declare function TextItemCreateTextItemData(asset: Asset, { MaxLength, Font, DialogPrefix, ChatTags, Dictionary, ScriptHooks, BaselineProperty, EventListeners, DrawData, PushOnPublish, }: TextItemConfig, parentOption?: null | ExtendedItemOption): TextItemData;
+/**
+ * @param {TextItemData} data - The extended item data
+ * @param {Item} item - The item in question
+ * @returns {{ newOption: TextItemOption, previousOption: TextItemOption }}
+ */
+declare function TextItemConstructOptions(data: TextItemData, item: Item): {
+    newOption: TextItemOption;
+    previousOption: TextItemOption;
+};
+/**
+ * Revert all text item properties back to their previous state prior to opening the extended item menu
+ * @param {TextItemData} data - The extended item data
+ * @param {Item} item - The item in question
+ */
+declare function TextItemPropertyRevert({ textNames }: TextItemData, item: Item): void;
+/**
+ * A lookup for the text item configurations for each registered text item
+ * @const
+ * @type {Record<string, TextItemData>}
+ * @see {@link TextItemData}
+ */
+declare const TextItemDataLookup: Record<string, TextItemData>;
+declare namespace TextItem {
+    function Init({ asset, font, baselineProperty, maxLength }: TextItemData, C: Character, item: Item, refresh?: boolean): boolean;
+    function Load(data: TextItemData): void;
+    function Draw({ asset, drawData, textNames }: TextItemData): void;
+    function Click({ functionPrefix, drawData }: TextItemData): void;
+    function Exit(data: TextItemData, publishAction?: boolean): void;
+    function PublishAction(data: TextItemData, C: Character, item: Item, newOption: TextItemOption, previousOption: TextItemOption): void;
+}
+/**
+ * Throttled callback for handling text changes.
+ * @type {TextItemEventListener}
+ */
+declare const TextItemChange: TextItemEventListener;
+/**
+ * Throttled callback for handling text changes that do not require a canvas.
+ * @type {TextItemEventListener}
+ */
+declare const TextItemChangeNoCanvas: TextItemEventListener;

package/bc/Scripts/TightenLoosenItem.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Loads the item properties
+ * @returns {void} Nothing
+ */
+declare function TightenLoosenItemLoad(): void;
+/**
+ * Draws the extended tighten / loosen menu
+ * @returns {void} Nothing
+ */
+declare function TightenLoosenItemDraw(): void;
+/**
+ * Sets a facial expression for the character being tightneded/loosened
+ * @param {Character} C - The character affected
+ * @param {"" | ExpressionNameMap["Blush"]} Blush - The blush style
+ * @param {"" | ExpressionNameMap["Eyes"]} Eyes - The eyes style
+ * @param {"" | ExpressionNameMap["Eyebrows"]} Eyebrows - The eyebrows style
+ * @returns {void} Nothing
+ */
+declare function TightenLoosenFacialExpression(C: Character, Blush: "" | ExpressionNameMap["Blush"], Eyes: "" | ExpressionNameMap["Eyes"], Eyebrows: "" | ExpressionNameMap["Eyebrows"]): void;
+/**
+ * Handles clicks on the tighten / loosen menu
+ * @returns {void} Nothing
+ */
+declare function TightenLoosenItemClick(): void;
+/**
+ * Exit function for sub menu
+ * @returns {void} - Nothing
+ */
+declare function TightenLoosenItemExit(): void;
+declare var TightenLoosenItemMaximumDifficulty: number;
+declare var TightenLoosenItemMinimumDifficulty: number;

package/bc/Scripts/Timer.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Returns the current time from the local computer clock
+ * @returns {number} - Returns the number of milliseconds
+ */
+declare function TimerGetTime(): number;
+/**
+ * Returns a string of the time remaining on a given timer
+ * @param {number} T - Time to convert to a string in ms
+ * @returns {string} - The time string in the DD:HH:MM:SS format (Days and hours not displayed if it contains none)
+ */
+declare function TimerToString(T: number): string;
+/**
+ * Returns a string of the time remaining on a given timer (Hours and minutes only)
+ * @param {Date} T - Time to convert to a string in ms
+ * @returns {string} - The time string in the HH:MM format
+ */
+declare function TimerHourToString(T: Date): string;
+/**
+ * Check if we must remove items from characters. (Expressions, items being removed, locks, etc.)
+ * @returns {void} - Nothing
+ */
+declare function TimerInventoryRemove(): void;
+/**
+ * Sets a remove timer in seconds for a specific item part / body part
+ * @param {Character} C - Character for which we are removing an item
+ * @param {AssetGroupName} AssetGroup - Group targeted by the removal
+ * @param {number} Timer - Seconds it takes to remove the item
+ * @returns {void} - Nothing
+ */
+declare function TimerInventoryRemoveSet(C: Character, AssetGroup: AssetGroupName, Timer: number): void;
+/**
+ * Sets a remove timer in seconds for expressions, adds to Expression Queue.
+ * @param {Character} C - Character for which we are changing expression.
+ * @param {ExpressionGroupName} ExpressionGroup - Group targeted by the removal.
+ * @param {number} Timer - Seconds it takes to change the expression.
+ * @param {ExpressionName} Expression - Expression to queue. Defaults to null if not specified.
+ * @returns {void} - Nothing
+ */
+declare function TimerExpressionQueuePush(C: Character, ExpressionGroup: ExpressionGroupName, Timer: number, Expression?: ExpressionName): void;
+/**
+ * Random trigger for the NPC owner in a private room. If possible, when triggered it will beep the player anywhere in the club, the player has 2 minutes to get back to her
+ * @returns {void} - Nothing
+ */
+declare function TimerPrivateOwnerBeep(): void;
+/**
+ * Main timer process
+ * @returns {void} - Nothing
+ */
+declare function TimerProcess(): void;
+/**
+ * Returns a string of the time remaining on a given timer (Hours, minutes, seconds)
+ * @param {number} s - Time to convert to a string in ms
+ * @returns {string} -  The time string in the HH:MM:SS format
+ */
+declare function TimermsToTime(s: number): string;
+declare var CurrentTime: number;
+declare var TimerRunInterval: number;
+declare var TimerLastTime: number;
+declare var TimerLastCycleCall: number;
+declare var TimerLastArousalProgress: number;
+declare var TimerLastArousalProgressCount: number;
+declare var TimerLastArousalDecay: number;

package/bc/Scripts/Translation.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Checks whether we're running a translation
+ */
+declare function TranslationEnabled(): boolean;
+/**
+ * Checks if a file can be translated in the selected language
+ * @param {string} FullPath - Full path of the file to check for a corresponding translation file
+ * @returns {boolean} - Returns TRUE if a translation is available for the given file
+ */
+declare function TranslationAvailable(FullPath: string): boolean;
+/**
+ * Parse a TXT translation file and returns it as an array
+ * @param {string} str - Content of the translation text file
+ * @returns {string[]} - Array of strings with each line divided. For each translated line, the english string precedes the translated one in the array.
+ */
+declare function TranslationParseTXT(str: string): string[];
+/**
+ * Translates a string to another language from the array, the translation is always the one right after the english line
+ * @param {string} S - The original english string to translate
+ * @param {readonly string[]} T - The active translation dictionary
+ * @returns {string} - The translated string
+ */
+declare function TranslationString(S: string, T: readonly string[]): string;
+/**
+ * Translates a character dialog from the specified array
+ * @param {Character} C - The character for which we need to translate the dialog array.
+ * @param {readonly string[]} T - The active translation dictionary
+ * @returns {void} - Nothing
+ */
+declare function TranslationDialogArray(C: Character, T: readonly string[]): void;
+/**
+ * Translates a set of tags. Rerenders the login message when on the login page.
+ * @param {readonly { Tag: string, Value: string }[]} S - Array of current tag-value pairs
+ * @param {readonly string[]} T - The active translation dictionary
+ * @returns {void} - Nothing
+ */
+declare function TranslationTextArray(S: readonly {
+    Tag: string;
+    Value: string;
+}[], T: readonly string[]): void;
+/**
+ * Loads a character dialog translation and caches it
+ * @param {Character} C - The character for which we want to translate the dialog
+ * @returns {void} - Nothing
+ */
+declare function TranslationLoadDialog(C: Character, cb: any): void;
+/**
+ * Translate a character dialog if the file is in the dictionary
+ * @param {Character} C
+ */
+declare function TranslationTranslateDialog(C: Character): void;
+/**
+ * Translate an array of tags in the current selected language
+ * @param {readonly {Tag: string, Value: string}[]} Text - Array of current tag-value pairs
+ * @returns {void} - Nothing
+ */
+declare function TranslationText(Text: readonly {
+    Tag: string;
+    Value: string;
+}[]): void;
+/**
+ * Translates the asset group and asset descriptions based on the given dictionary
+ * @param {string[]} T - The active translation dictionary
+ * @returns {void} - Nothing
+ */
+declare function TranslationAssetProcess(T: string[]): void;
+/**
+ * Translates the description of the assets and groups of an asset family
+ * @param {IAssetFamily} Family - Name of the asset family to translate
+ * @returns {void} - Nothing
+ */
+declare function TranslationAsset(Family: IAssetFamily): void;
+/**
+ * Returns the translated language name for the given code.
+ * @param {string} code - The language code to get the human-readable name of.
+ * @param {boolean} [english] - Get the english name of it.
+ */
+declare function TranslationGetLanguageName(code: string, english?: boolean): string;
+/**
+ * Changes the current language and save the new selected language to local storage
+ * @returns {void} - Nothing
+ */
+declare function TranslationNextLanguage(): void;
+/**
+ * Loads the previous translation language from local storage if it exists
+ * @returns {void} - Nothing
+ */
+declare function TranslationLoad(): void;
+declare var TranslationLanguage: string;
+/** @type {Record<string, string[]>} */
+declare var TranslationCache: Record<string, string[]>;
+/**
+ * Dictionary for all supported languages and their files
+ * @constant
+ */
+declare var TranslationDictionary: {
+    LanguageCode: string;
+    LanguageName: string;
+    EnglishName: string;
+    Files: string[];
+}[];

package/bc/Scripts/TypedItem.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Registers a typed extended item. This automatically creates the item's load, draw and click functions. It will also
+ * generate the asset's AllowType array.
+ * @param {Asset} asset - The asset being registered
+ * @param {TypedItemConfig} config - The item's typed item configuration
+ * @returns {TypedItemData} - The generated extended item data for the asset
+ */
+declare function TypedItemRegister(asset: Asset, config: TypedItemConfig): TypedItemData;
+/**
+ * Parse and pre-process the passed item options.
+ * @param {Asset} asset - The item options asset
+ * @param {readonly TypedItemOptionConfig[]} protoOptions - The unparsed extended item options
+ * @param {boolean} [changeWhenLocked] - See {@link TypedItemConfig.ChangeWhenLocked}
+ * @returns {TypedItemOption[]} The newly generated extended item options
+ */
+declare function TypedItemBuildOptions(protoOptions: readonly TypedItemOptionConfig[], asset: Asset, changeWhenLocked?: boolean): TypedItemOption[];
+/**
+ * Parse the passed typed item draw data as passed via the extended item config
+ * @param {Asset} asset - The asset in question
+ * @param {ExtendedItemConfigDrawData<Partial<ElementMetaData.Typed>> | undefined} drawData - The to-be parsed draw data
+ * @param {readonly { Name: string }[]} options - The list of extended item options
+ * @param {Partial<ElementMetaData.Typed>} overrideMetaData
+ * @return {ExtendedItemDrawData<ElementMetaData.Typed>} - The parsed draw data
+ */
+declare function TypedItemGetDrawData(asset: Asset, drawData: ExtendedItemConfigDrawData<Partial<ElementMetaData.Typed>> | undefined, options: readonly {
+    Name: string;
+}[], overrideMetaData?: Partial<ElementMetaData.Typed>): ExtendedItemDrawData<ElementMetaData.Typed>;
+/**
+ * Generates an asset's typed item data
+ * @param {Asset} asset - The asset to generate modular item data for
+ * @param {TypedItemConfig} config - The item's extended item configuration
+ * @returns {TypedItemData} - The generated typed item data for the asset
+ */
+declare function TypedItemCreateTypedItemData(asset: Asset, { Options, DialogPrefix, ChatTags, Dictionary, ChatSetting, DrawImages, ChangeWhenLocked, ScriptHooks, DrawData, BaselineProperty, }: TypedItemConfig): TypedItemData;
+/**
+ *
+ * @param {TypedItemData} data
+ * @param {Character} C
+ * @param {Item} item
+ * @param {TypedItemOption} newOption
+ * @param {TypedItemOption} previousOption
+ */
+declare function TypedItemPublishAction(data: TypedItemData, C: Character, item: Item, newOption: TypedItemOption, previousOption: TypedItemOption): void;
+/**
+ * Generates an asset's AllowType property based on its typed item data.
+ * @param {TypedItemData} data - The typed item's data
+ * @returns {void} - Nothing
+ */
+declare function TypedItemGenerateAllowType({ asset, options }: TypedItemData): void;
+/**
+ * Generates an asset's AllowEffect property based on its typed item data.
+ * @param {TypedItemData} data - The typed item's data
+ * @returns {void} - Nothing
+ */
+declare function TypedItemGenerateAllowEffect({ asset, options }: TypedItemData): void;
+/**
+ * Generates an asset's AllowBlock property based on its typed item data.
+ * @param {TypedItemData} data - The typed item's data
+ * @returns {void} - Nothing
+ */
+declare function TypedItemGenerateAllowBlock({ asset, options }: TypedItemData): void;
+/**
+ * Generates an asset's AllowHide & AllowHideItem properties based on its typed item data.
+ * @param {TypedItemData} data - The typed item's data
+ * @returns {void} - Nothing
+ */
+declare function TypedItemGenerateAllowHide({ asset, options }: TypedItemData): void;
+/**
+ * Generates an asset's AllowTint property based on its typed item data.
+ * @param {TypedItemData} data - The typed item's data
+ * @returns {void} - Nothing
+ */
+declare function TypedItemGenerateAllowTint({ asset, options }: TypedItemData): void;
+/**
+ * Generates an asset's AllowLockType property based on its typed item data.
+ * @param {TypedItemData} data - The typed item's data
+ * @returns {void} - Nothing
+ */
+declare function TypedItemGenerateAllowLockType({ asset, options }: TypedItemData): void;
+/**
+ * Sets the AllowLock and AllowLockType properties on an asset based on an AllowLockType array and the total number of
+ * possible types.
+ * @param {Asset} asset - The asset to set properties on
+ * @param {readonly string[]} allowLockType - The AllowLockType array indicating which of the asset's types permit locks
+ * @param {number} typeCount - The total number of types available on the asset
+ * @returns {void} - Nothing
+ */
+declare function TypedItemSetAllowLockType(asset: Asset, allowLockType: readonly string[], typeCount: number): void;
+/**
+ * Returns the options configuration array for a typed item
+ * @param {AssetGroupName} groupName - The name of the asset group
+ * @param {string} assetName - The name of the asset
+ * @returns {TypedItemOption[]|null} - The options array for the item, or null if no typed item data was found
+ */
+declare function TypedItemGetOptions(groupName: AssetGroupName, assetName: string): TypedItemOption[] | null;
+/**
+ * Returns a list of typed item option names available for the given asset, or an empty array if the asset is not typed
+ * @param {AssetGroupName} groupName - The name of the asset group
+ * @param {string} assetName - The name of the asset
+ * @returns {string[]} - The option names available for the asset, or an empty array if the asset is not typed or no
+ * typed item data was found
+ */
+declare function TypedItemGetOptionNames(groupName: AssetGroupName, assetName: string): string[];
+/**
+ * Returns the named option configuration object for a typed item
+ * @param {AssetGroupName} groupName - The name of the asset group
+ * @param {string} assetName - The name of the asset
+ * @param {string} optionName - The name of the option
+ * @returns {TypedItemOption|null} - The named option configuration object, or null if none was found
+ */
+declare function TypedItemGetOption(groupName: AssetGroupName, assetName: string, optionName: string): TypedItemOption | null;
+/**
+ * Validates a selected option. A typed item may provide a custom validation function. Returning a non-empty string from
+ * the validation function indicates that the new option is not compatible with the character's current state (generally
+ * due to prerequisites or other requirements).
+ * @template {ExtendedItemOption} T
+ * @param {null | ExtendedItemData<T>} data
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item} item - The item whose options are being validated
+ * @param {T} option - The new option
+ * @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.
+ */
+declare function TypedItemValidateOption<T extends ExtendedItemOption>(data: ExtendedItemData<T>, C: Character, item: Item, option: T, previousOption: T, permitExisting?: boolean): string | undefined;
+/**
+ * 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
+ * @param {Item | AssetGroupName} itemOrGroupName - The item whose type to set, or the group name for the item
+ * @param {string} optionName - The name of the option to set
+ * @param {boolean} [push] - Whether or not appearance updates should be persisted (only applies if the character is the
+ * player) - defaults to false.
+ * @param {null | Character} [C_Source] - The character setting the new item option. If `null`, assume that it is _not_ the player character.
+ * @param {null | [archetype: "typed" | "vibrating", screen: string]} [subscreen]
+ * @returns {string|undefined} - undefined or an empty string if the type was set correctly. Otherwise, returns a string
+ * informing the player of the requirements that are not met.
+ */
+declare function TypedItemSetOptionByName(C: Character, itemOrGroupName: Item | AssetGroupName, optionName: string, push?: boolean, C_Source?: null | Character, subscreen?: null | [archetype: "typed" | "vibrating", screen: string]): string | undefined;
+/**
+ * Finds the currently set option on the given typed item
+ * @template {TypedItemOption | VibratingItemOption} T
+ * @param {Item} item - The equipped item
+ * @param {readonly T[]} options - The list of available options for the item
+ * @param {"Type" | "Mode"} typeField - The name of the item property field containing the item's type (or equivalent thereof)
+ * @returns {T} - The option which is currently applied to the item, or the first item in the options
+ * array if no type is set.
+ */
+declare function TypedItemFindPreviousOption<T extends TypedItemOption | VibratingItemOption>(item: Item, options: readonly T[], typeField?: "Type" | "Mode"): T;
+/**
+ * Sets a typed item's type to a random option, respecting prerequisites and option validation.
+ * @param {Character} C - The character on whom the item is equipped
+ * @param {Item | AssetGroupName} itemOrGroupName - The item whose type to set, or the group name for the item
+ * @param {boolean} [push] - Whether or not appearance updates should be persisted (only applies if the character is the
+ * player) - defaults to false.
+ * @param {null | Character} [C_Source] - The character setting the new item option. If `null`, assume that it is _not_ the player character.
+ * @returns {string|undefined} - undefined or an empty string if the type was set correctly. Otherwise, returns a string
+ * informing the player of the requirements that are not met.
+ */
+declare function TypedItemSetRandomOption(C: Character, itemOrGroupName: Item | AssetGroupName, push?: boolean, C_Source?: null | Character): string | undefined;
+/**
+ * Initialize the typed item properties
+ * @param {TypedItemData} Data - The item's extended item 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 TypedItemInit(Data: TypedItemData, C: Character, Item: Item, Refresh?: boolean): boolean;
+/**
+ * Draws the extended item type selection screen
+ * @param {TypedItemData | VibratingItemData} data - An Array of type definitions for each allowed extended type. The first item
+ *     in the array should be the default option.
+ * @returns {void} Nothing
+ */
+declare function TypedItemDraw({ functionPrefix, options, parentOption, dialogPrefix, drawData, archetype }: TypedItemData | VibratingItemData): void;
+/**
+ * Handles clicks on the extended item type selection screen
+ * @param {TypedItemData | VibratingItemData} data
+ * @returns {void} Nothing
+ */
+declare function TypedItemClick(data: TypedItemData | VibratingItemData): void;
+/**
+ * Handler function called when an option on the type selection screen is clicked
+ * @template {TypedItemOption | VibratingItemOption} T
+ * @param {ExtendedItemData<T> & { options: T[] }} data
+ * @param {Character} C - The character wearing the item
+ * @param {T} Option - The selected type definition
+ * @returns {void} Nothing
+ */
+declare function TypedItemHandleOptionClick<T extends TypedItemOption | VibratingItemOption>(data: ExtendedItemData<T> & {
+    options: T[];
+}, C: Character, Option: T): void;
+/**
+ * Handler function for setting the type of an typed item
+ * @template {TypedItemOption | VibratingItemOption} T
+ * @param {ExtendedItemData<T> & { options: T[] }} data
+ * @param {Character} C - The character wearing the item
+ * @param {T} newOption - The selected type definition
+ * @returns {void} Nothing
+ */
+declare function TypedItemSetType<T extends TypedItemOption | VibratingItemOption>(data: ExtendedItemData<T> & {
+    options: T[];
+}, C: Character, newOption: T): void;
+/**
+ * TypedItem.js
+ * ------------
+ * This file contains utilities related to typed extended items (items that allow switching between a selection of
+ * different states). It is generally not necessary to call functions in this file directly - these are called from
+ * Asset.js when an item is first registered.
+ *
+ * All dialogue for typed items should be added to `Dialog_Player.csv`. To implement a typed item, you need the
+ * following dialogue entries (these dialogue keys can also be configured through the item's configuration if custom
+ * dialogue keys are needed):
+ *  * "<GroupName><AssetName>Select" - This is the text that will be displayed at the top of the extended item screen
+ *    (usually a prompt for the player to select a type)
+ *  * For each type:
+ *    * "<GroupName><AssetName><TypeName>" - This is the display name for the given type
+ *  * If the item's chat setting is configured to `TO_ONLY`, you will need a chatroom message for each type, which will
+ *    be sent when that type is selected. It should have the format "<GroupName><AssetName>Set<TypeName>" (e.g.
+ *    "ItemArmsLatexBoxtieLeotardSetPolished" - "SourceCharacter polishes the latex of DestinationCharacter leotard
+ *    until it's shiny")
+ *  * If the item's chat setting is configured to `FROM_TO`, you will need a chatroom message for each possible type
+ *    pairing, which will be sent when the item's type changes from the first type to the second type. It should have
+ *    the format "<GroupName><AssetName>Set<Type1>To<Type2>".
+ */
+/**
+ * A lookup for the typed item configurations for each registered typed item
+ * @const
+ * @type {Record<string, TypedItemData>}
+ * @see {@link TypedItemData}
+ */
+declare const TypedItemDataLookup: Record<string, TypedItemData>;
+/**
+ * An enum encapsulating the possible chatroom message settings for typed items
+ * - TO_ONLY - The item has one chatroom message per type (indicating that the type has been selected)
+ * - FROM_TO - The item has a chatroom message for from/to type pairing
+ * - SILENT - The item doesn't publish an action when a type is selected.
+ * @type {Record<"TO_ONLY"|"FROM_TO"|"SILENT", TypedItemChatSetting>}
+ */
+declare const TypedItemChatSetting: Record<"TO_ONLY" | "FROM_TO" | "SILENT", TypedItemChatSetting>;