fvtt-types/src/foundry/common/constants.d.mts

TypeScript type definitions for Foundry VTT

import type { Brand, DeepReadonly, Identity, ValueOf } from "#utils";

/**
 * The shortened software name
 */
export declare const vtt: "Foundry VTT";

/**
 * The full software name
 */
export declare const VTT: "Foundry Virtual Tabletop";

/**
 * The software website URL
 */
export declare const WEBSITE_URL: "https://foundryvtt.com";

/**
 * The serverless API URL
 */
export declare const WEBSITE_API_URL: "https://api.foundryvtt.com";

/**
 * An ASCII greeting displayed to the client
 */
export const ASCII = `_______________________________________________________________
 _____ ___  _   _ _   _ ____  ______   __ __     _______ _____
|  ___/ _ \\| | | | \\ | |  _ \\|  _ \\ \\ / / \\ \\   / |_   _|_   _|
| |_ | | | | | | |  \\| | | | | |_) \\ V /   \\ \\ / /  | |   | |
|  _|| |_| | |_| | |\\  | |_| |  _ < | |     \\ V /   | |   | |
|_|   \\___/ \\___/|_| \\_|____/|_| \\_\\|_|      \\_/    |_|   |_|
===============================================================`;

/**
 * Define the allowed ActiveEffect application modes.
 * Other arbitrary mode numbers can be used by systems and modules to identify special behaviors and are ignored
 */
export declare const ACTIVE_EFFECT_MODES: Readonly<{
  /**
   * Used to denote that the handling of the effect is programmatically provided by a system or module.
   */
  CUSTOM: 0 & ACTIVE_EFFECT_MODES;

  /**
   * Multiplies a numeric base value by the numeric effect value
   * @example
   * 2 (base value) * 3 (effect value) = 6 (derived value)
   */
  MULTIPLY: 1 & ACTIVE_EFFECT_MODES;

  /**
   * Adds a numeric base value to a numeric effect value, or concatenates strings
   * @example
   * 2 (base value) + 3 (effect value) = 5 (derived value)
   * @example
   * "Hello" (base value) + " World" (effect value) = "Hello World"
   */
  ADD: 2 & ACTIVE_EFFECT_MODES;

  /**
   * Keeps the lower value of the base value and the effect value
   * @example
   * 2 (base value), 0 (effect value) = 0 (derived value)
   * @example
   * 2 (base value), 3 (effect value) = 2 (derived value)
   */
  DOWNGRADE: 3 & ACTIVE_EFFECT_MODES;

  /**
   * Keeps the greater value of the base value and the effect value
   * @example
   * 2 (base value), 4 (effect value) = 4 (derived value)
   * @example
   * 2 (base value), 1 (effect value) = 2 (derived value)
   */
  UPGRADE: 4 & ACTIVE_EFFECT_MODES;

  /**
   * Directly replaces the base value with the effect value
   * @example
   * 2 (base value), 4 (effect value) = 4 (derived value)
   */
  OVERRIDE: 5 & ACTIVE_EFFECT_MODES;
}>;
export type ACTIVE_EFFECT_MODES = Brand<number, "constants.ACTIVE_EFFECT_MODES">;

/**
 * Define the string name used for the base document type when specific sub-types are not defined by the system
 */
export declare const BASE_DOCUMENT_TYPE: "base";
export type BASE_DOCUMENT_TYPE = typeof BASE_DOCUMENT_TYPE;

/**
 * Define the methods by which a Card can be drawn from a Cards stack
 * @remarks `TOP` and `FIRST` are synonymous, as are `BOTTOM` and `LAST`.
 */
export declare const CARD_DRAW_MODES: Readonly<{
  /**
   * Draw the first card from the stack
   * Synonymous with {@linkcode CARD_DRAW_MODES.TOP}
   */
  FIRST: 0 & CARD_DRAW_MODES;

  /**
   * Draw the top card from the stack
   * Synonymous with {@linkcode CARD_DRAW_MODES.FIRST}
   */
  TOP: 0 & CARD_DRAW_MODES;

  /**
   * Draw the last card from the stack
   * Synonymous with {@linkcode CARD_DRAW_MODES.BOTTOM}
   */
  LAST: 1 & CARD_DRAW_MODES;

  /**
   * Draw the bottom card from the stack
   * Synonymous with {@linkcode CARD_DRAW_MODES.LAST}
   */
  BOTTOM: 1 & CARD_DRAW_MODES;

  /**
   * Draw a random card from the stack
   */
  RANDOM: 2 & CARD_DRAW_MODES;
}>;
export type CARD_DRAW_MODES = Brand<number, "constants.CARD_DRAW_MODES">;

/**
 * An enumeration of canvas performance modes.
 */
export declare const CANVAS_PERFORMANCE_MODES: Readonly<{
  LOW: 0 & CANVAS_PERFORMANCE_MODES;
  MED: 1 & CANVAS_PERFORMANCE_MODES;
  HIGH: 2 & CANVAS_PERFORMANCE_MODES;
  MAX: 3 & CANVAS_PERFORMANCE_MODES;
}>;
export type CANVAS_PERFORMANCE_MODES = Brand<number, "constants.CANVAS_PERFORMANCE_MODES">;

/**
 * Valid Chat Message styles which affect how the message is presented in the chat log.
 */
export declare const CHAT_MESSAGE_STYLES: Readonly<{
  /**
   * An uncategorized chat message
   */
  OTHER: 0 & CHAT_MESSAGE_STYLES;

  /**
   * The message is spoken out of character (OOC).
   * OOC messages will be outlined by the player's color to make them more easily recognizable.
   */
  OOC: 1 & CHAT_MESSAGE_STYLES;

  /**
   * The message is spoken by an associated character.
   */
  IC: 2 & CHAT_MESSAGE_STYLES;

  /**
   * The message is an emote performed by the selected character.
   * Entering "/emote waves his hand." while controlling a character named Simon will send the message, "Simon waves his hand."
   */
  EMOTE: 3 & CHAT_MESSAGE_STYLES;

  /**
   * @deprecated "`CONST.CHAT_MESSAGE_STYLES.ROLL` is deprecated in favor of defining rolls directly in
   * {@linkcode ChatMessage.rolls | ChatMessage#rolls}" (since v12, until v14)
   */
  ROLL: 0 & CHAT_MESSAGE_STYLES;

  /**
   * @deprecated "`CONST.CHAT_MESSAGE_STYLES.Whisper` is deprecated in favor of defining whisper recipients
   * directly in {@linkcode ChatMessage.whisper | ChatMessage#whisper}"
   * (since v12, until v14)
   */
  WHISPER: 0 & CHAT_MESSAGE_STYLES;
}>;
export type CHAT_MESSAGE_STYLES = Brand<number, "constants.CHAT_MESSAGE_STYLES">;

/**
 * Define the set of languages which have built-in support in the core software
 */
export declare const CORE_SUPPORTED_LANGUAGES: readonly ["en"];
export type CORE_SUPPORTED_LANGUAGES = ValueOf<typeof CORE_SUPPORTED_LANGUAGES>;

/**
 * Configure the severity of compatibility warnings.
 */
export declare const COMPATIBILITY_MODES: Readonly<{
  /**
   * Nothing will be logged
   */
  SILENT: 0 & COMPATIBILITY_MODES;

  /**
   * A message will be logged at the "warn" level
   */
  WARNING: 1 & COMPATIBILITY_MODES;

  /**
   * A message will be logged at the "error" level
   */
  ERROR: 2 & COMPATIBILITY_MODES;

  /**
   * An Error will be thrown
   */
  FAILURE: 3 & COMPATIBILITY_MODES;
}>;
export type COMPATIBILITY_MODES = Brand<number, "constants.COMPATIBILITY_MODES">;

/**
 * Configure custom cursor images to use when interacting with the application.
 */
export declare const CURSOR_STYLES: Readonly<{
  default: "default";
  "default-down": "default";
  pointer: "pointer";
  "pointer-down": "pointer";
  grab: "grab";
  "grab-down": "grabbing";
  text: "text";
  "text-down": "text";
}>;
export type CURSOR_STYLES = keyof typeof CURSOR_STYLES;

/**
 * The lighting illumination levels which are supported.
 */
export declare const LIGHTING_LEVELS: Readonly<{
  DARKNESS: -2 & LIGHTING_LEVELS;
  HALFDARK: -1 & LIGHTING_LEVELS;
  UNLIT: 0 & LIGHTING_LEVELS;
  DIM: 1 & LIGHTING_LEVELS;
  BRIGHT: 2 & LIGHTING_LEVELS;
  BRIGHTEST: 3 & LIGHTING_LEVELS;
}>;
export type LIGHTING_LEVELS = Brand<number, "constants.LIGHTING_LEVELS">;

/**
 * The CSS themes which are currently supported for the V11 Setup menu.
 */
export declare const CSS_THEMES: Readonly<{
  foundry: "THEME.foundry";
  fantasy: "THEME.fantasy";
  scifi: "THEME.scifi";
}>;
export type CSS_THEMES = ValueOf<typeof CSS_THEMES>;

/**
 * The default artwork used for Token images if none is provided
 */
export declare const DEFAULT_TOKEN: "icons/svg/mystery-man.svg";
export type DEFAULT_TOKEN = typeof DEFAULT_TOKEN;

/**
 * Define the allowed Document class types.
 */
export declare const PRIMARY_DOCUMENT_TYPES: readonly [
  "Actor",
  "Adventure",
  "Cards",
  "ChatMessage",
  "Combat",
  "FogExploration",
  "Folder",
  "Item",
  "JournalEntry",
  "Macro",
  "Playlist",
  "RollTable",
  "Scene",
  "Setting",
  "User",
];
export type PRIMARY_DOCUMENT_TYPES = ValueOf<typeof PRIMARY_DOCUMENT_TYPES>;

/**
 * The embedded Document types.
 */
export const EMBEDDED_DOCUMENT_TYPES: readonly [
  "ActiveEffect",
  "ActorDelta",
  "AmbientLight",
  "AmbientSound",
  "Card",
  "Combatant",
  "CombatantGroup",
  "Drawing",
  "Item",
  "JournalEntryCategory",
  "JournalEntryPage",
  "MeasuredTemplate",
  "Note",
  "PlaylistSound",
  "Region",
  "RegionBehavior",
  "TableResult",
  "Tile",
  "Token",
  "Wall",
];
export type EMBEDDED_DOCUMENT_TYPES = ValueOf<typeof EMBEDDED_DOCUMENT_TYPES>;

/**
 * A listing of all valid Document types, both primary and embedded.
 */
export const ALL_DOCUMENT_TYPES: readonly ALL_DOCUMENT_TYPES[];
export type ALL_DOCUMENT_TYPES = PRIMARY_DOCUMENT_TYPES | EMBEDDED_DOCUMENT_TYPES;

/**
 * The allowed primary Document types which may exist within a World.
 */
export declare const WORLD_DOCUMENT_TYPES: readonly [
  "Actor",
  "Cards",
  "ChatMessage",
  "Combat",
  "FogExploration",
  "Folder",
  "Item",
  "JournalEntry",
  "Macro",
  "Playlist",
  "RollTable",
  "Scene",
  "Setting",
  "User",
];
export type WORLD_DOCUMENT_TYPES = ValueOf<typeof WORLD_DOCUMENT_TYPES>;

/**
 * The allowed primary Document types which may exist within a Compendium pack.
 */
export declare const COMPENDIUM_DOCUMENT_TYPES: readonly [
  "Actor",
  "Adventure",
  "Cards",
  "Item",
  "JournalEntry",
  "Macro",
  "Playlist",
  "RollTable",
  "Scene",
];
export type COMPENDIUM_DOCUMENT_TYPES = ValueOf<typeof COMPENDIUM_DOCUMENT_TYPES>;

/**
 * Define the allowed ownership levels for a Document.
 * Each level is assigned a value in ascending order.
 * Higher levels grant more permissions.
 * @see {@link https://foundryvtt.com/article/users/}
 */
export declare const DOCUMENT_OWNERSHIP_LEVELS: Readonly<{
  /**
   * The User inherits permissions from the parent Folder.
   */
  INHERIT: -1 & DOCUMENT_OWNERSHIP_LEVELS;

  /**
   * Restricts the associated Document so that it may not be seen by this User.
   */
  NONE: 0 & DOCUMENT_OWNERSHIP_LEVELS;

  /**
   * Allows the User to interact with the Document in basic ways, allowing them to see it in sidebars and see only limited aspects of its contents.
   * The limits of this interaction are defined by the game system being used.
   */
  LIMITED: 1 & DOCUMENT_OWNERSHIP_LEVELS;

  /**
   * Allows the User to view this Document as if they were owner, but prevents them from making any changes to it.
   */
  OBSERVER: 2 & DOCUMENT_OWNERSHIP_LEVELS;

  /**
   * Allows the User to view and make changes to the Document as its owner. Owned documents cannot be deleted by anyone other than a gamemaster level User.
   */
  OWNER: 3 & DOCUMENT_OWNERSHIP_LEVELS;
}>;
export type DOCUMENT_OWNERSHIP_LEVELS = Brand<number, "constants.DOCUMENT_OWNERSHIP_LEVELS">;

/**
 * Meta ownership levels that are used in the UI but never stored.
 */
export declare const DOCUMENT_META_OWNERSHIP_LEVELS: Readonly<{
  DEFAULT: -20 & DOCUMENT_META_OWNERSHIP_LEVELS;
  NOCHANGE: -10 & DOCUMENT_META_OWNERSHIP_LEVELS;
}>;
export type DOCUMENT_META_OWNERSHIP_LEVELS = Brand<number, "constants.DOCUMENT_META_OWNERSHIP_LEVELS">;

/**
 * Define the allowed Document types which may be dynamically linked in chat
 */
export declare const DOCUMENT_LINK_TYPES: readonly [
  "Actor",
  "Cards",
  "Item",
  "Scene",
  "JournalEntry",
  "Macro",
  "RollTable",
  "PlaylistSound",
];
export type DOCUMENT_LINK_TYPES = ValueOf<typeof DOCUMENT_LINK_TYPES>;

/**
 * The supported dice roll visibility modes
 * @see {@link https://foundryvtt.com/article/dice/}
 */
export declare const DICE_ROLL_MODES: Readonly<{
  /**
   * This roll is visible to all players.
   */
  PUBLIC: "publicroll";

  /**
   * Rolls of this type are only visible to the player that rolled and any Game Master users.
   */
  PRIVATE: "gmroll";

  /**
   * A private dice roll only visible to Gamemaster users. The rolling player will not see the result of their own roll.
   */
  BLIND: "blindroll";

  /**
   * A private dice roll which is only visible to the user who rolled it.
   */
  SELF: "selfroll";
}>;
export type DICE_ROLL_MODES = ValueOf<typeof DICE_ROLL_MODES>;

/**
 * The allowed fill types which a Drawing object may display
 * @see {@link https://foundryvtt.com/article/drawings/}
 */
export declare const DRAWING_FILL_TYPES: Readonly<{
  /**
   * The drawing is not filled
   */
  NONE: 0 & DRAWING_FILL_TYPES;

  /**
   * The drawing is filled with a solid color
   */
  SOLID: 1 & DRAWING_FILL_TYPES;

  /**
   * The drawing is filled with a tiled image pattern
   */
  PATTERN: 2 & DRAWING_FILL_TYPES;
}>;
export type DRAWING_FILL_TYPES = Brand<number, "constants.DRAWING_FILL_TYPES">;

/**
 * Define the allowed Document types which Folders may contain
 */
export declare const FOLDER_DOCUMENT_TYPES: readonly [
  "Actor",
  "Adventure",
  "Item",
  "Scene",
  "JournalEntry",
  "Playlist",
  "RollTable",
  "Cards",
  "Macro",
  "Compendium",
];
export type FOLDER_DOCUMENT_TYPES = ValueOf<typeof FOLDER_DOCUMENT_TYPES>;

/**
 * The maximum allowed level of depth for Folder nesting
 * @defaultValue `4`
 */
export declare const FOLDER_MAX_DEPTH: number;

/**
 * A list of allowed game URL names
 */
export declare const GAME_VIEWS: readonly ["game", "stream"];
export type GAME_VIEWS = ValueOf<typeof GAME_VIEWS>;

/**
 * The directions of movement.
 */
export declare const MOVEMENT_DIRECTIONS: Readonly<{
  UP: 0x1 & MOVEMENT_DIRECTIONS;
  DOWN: 0x2 & MOVEMENT_DIRECTIONS;
  LEFT: 0x4 & MOVEMENT_DIRECTIONS;
  RIGHT: 0x8 & MOVEMENT_DIRECTIONS;

  /** @remarks `0x1 | 0x4` */
  UP_LEFT: 0x5 & MOVEMENT_DIRECTIONS;

  /** @remarks `0x1 | 0x8` */
  UP_RIGHT: 0x9 & MOVEMENT_DIRECTIONS;

  /** @remarks `0x2 | 0x4` */
  DOWN_LEFT: 0x6 & MOVEMENT_DIRECTIONS;

  /** @remarks `0x2 | 0x8` */
  DOWN_RIGHT: 0xa & MOVEMENT_DIRECTIONS;
}>;
export type MOVEMENT_DIRECTIONS = Brand<number, "constants.MOVEMENT_DIRECTIONS">;

/**
 * The minimum allowed grid size which is supported by the software
 * @defaultValue `20`
 */
export declare const GRID_MIN_SIZE: number;

/**
 * The allowed Grid types which are supported by the software
 * @see {@link https://foundryvtt.com/article/scenes/}
 */
export declare const GRID_TYPES: Readonly<{
  /**
   * No fixed grid is used on this Scene allowing free-form point-to-point measurement without grid lines.
   */
  GRIDLESS: 0 & GRID_TYPES;

  /**
   * A square grid is used with width and height of each grid space equal to the chosen grid size.
   */
  SQUARE: 1 & GRID_TYPES;

  /**
   * A row-wise hexagon grid (pointy-topped) where odd-numbered rows are offset.
   */
  HEXODDR: 2 & GRID_TYPES;

  /**
   * A row-wise hexagon grid (pointy-topped) where even-numbered rows are offset.
   */
  HEXEVENR: 3 & GRID_TYPES;

  /**
   * A column-wise hexagon grid (flat-topped) where odd-numbered columns are offset.
   */
  HEXODDQ: 4 & GRID_TYPES;

  /**
   * A column-wise hexagon grid (flat-topped) where even-numbered columns are offset.
   */
  HEXEVENQ: 5 & GRID_TYPES;
}>;
export type GRID_TYPES = Brand<number, "constants.GRID_TYPES">;

/**
 * The different rules to define and measure diagonal distance/cost in a square grid.
 * The description of each option refers to the distance/cost of moving diagonally relative to the distance/cost of a
 * horizontal or vertical move.
 */
export declare const GRID_DIAGONALS: Readonly<{
  /**
   * The diagonal distance is 1. Diagonal movement costs the same as horizontal/vertical movement.
   */
  EQUIDISTANT: 0 & GRID_DIAGONALS;

  /**
   * The diagonal distance is √2. Diagonal movement costs √2 times as much as horizontal/vertical movement.
   */
  EXACT: 1 & GRID_DIAGONALS;

  /**
   * The diagonal distance is 1.5. Diagonal movement costs 1.5 times as much as horizontal/vertical movement.
   */
  APPROXIMATE: 2 & GRID_DIAGONALS;

  /**
   * The diagonal distance is 2. Diagonal movement costs 2 times as much as horizontal/vertical movement.
   */
  RECTILINEAR: 3 & GRID_DIAGONALS;

  /**
   * The diagonal distance alternates between 1 and 2 starting at 1.
   * The first diagonal movement costs the same as horizontal/vertical movement
   * The second diagonal movement costs 2 times as much as horizontal/vertical movement.
   * And so on...
   */
  ALTERNATING_1: 4 & GRID_DIAGONALS;

  /**
   * The diagonal distance alternates between 2 and 1 starting at 2.
   * The first diagonal movement costs 2 times as much as horizontal/vertical movement.
   * The second diagonal movement costs the same as horizontal/vertical movement.
   * And so on...
   */
  ALTERNATING_2: 5 & GRID_DIAGONALS;

  /**
   * The diagonal distance is ∞. Diagonal movement is not allowed/possible.
   */
  ILLEGAL: 6 & GRID_DIAGONALS;
}>;
export type GRID_DIAGONALS = Brand<number, "constants.GRID_DIAGONALS">;

/**
 * The grid snapping modes.
 */
export declare const GRID_SNAPPING_MODES: Readonly<{
  /**
   * Nearest center point.
   */
  CENTER: 0x1 & GRID_SNAPPING_MODES;

  /**
   * Nearest edge midpoint.
   */
  EDGE_MIDPOINT: 0x2 & GRID_SNAPPING_MODES;

  /**
   * Nearest top-left vertex.
   */
  TOP_LEFT_VERTEX: 0x10 & GRID_SNAPPING_MODES;

  /**
   * Nearest top-right vertex.
   */
  TOP_RIGHT_VERTEX: 0x20 & GRID_SNAPPING_MODES;

  /**
   * Nearest bottom-left vertex.
   */
  BOTTOM_LEFT_VERTEX: 0x40 & GRID_SNAPPING_MODES;

  /**
   * Nearest bottom-right vertex.
   */
  BOTTOM_RIGHT_VERTEX: 0x80 & GRID_SNAPPING_MODES;

  /**
   * Nearest vertex.
   * Alias for `TOP_LEFT_VERTEX | TOP_RIGHT_VERTEX | BOTTOM_LEFT_VERTEX | BOTTOM_RIGHT_VERTEX`.
   */
  VERTEX: 0xf0 & GRID_SNAPPING_MODES;

  /**
   * Nearest top-left corner.
   */
  TOP_LEFT_CORNER: 0x100 & GRID_SNAPPING_MODES;

  /**
   * Nearest top-right corner.
   */
  TOP_RIGHT_CORNER: 0x200 & GRID_SNAPPING_MODES;

  /**
   * Nearest bottom-left corner.
   */
  BOTTOM_LEFT_CORNER: 0x400 & GRID_SNAPPING_MODES;

  /**
   * Nearest bottom-right corner.
   */
  BOTTOM_RIGHT_CORNER: 0x800 & GRID_SNAPPING_MODES;

  /**
   * Nearest corner.
   * Alias for `TOP_LEFT_CORNER | TOP_RIGHT_CORNER | BOTTOM_LEFT_CORNER | BOTTOM_RIGHT_CORNER`.
   */
  CORNER: 0xf00 & GRID_SNAPPING_MODES;

  /**
   * Nearest top side midpoint.
   */
  TOP_SIDE_MIDPOINT: 0x1000 & GRID_SNAPPING_MODES;

  /**
   * Nearest bottom side midpoint.
   */
  BOTTOM_SIDE_MIDPOINT: 0x2000 & GRID_SNAPPING_MODES;

  /**
   * Nearest left side midpoint.
   */
  LEFT_SIDE_MIDPOINT: 0x4000 & GRID_SNAPPING_MODES;

  /**
   * Nearest right side midpoint.
   */
  RIGHT_SIDE_MIDPOINT: 0x8000 & GRID_SNAPPING_MODES;

  /**
   * Nearest side midpoint.
   * Alias for `TOP_SIDE_MIDPOINT | BOTTOM_SIDE_MIDPOINT | LEFT_SIDE_MIDPOINT | RIGHT_SIDE_MIDPOINT`.
   */
  SIDE_MIDPOINT: 0xf000 & GRID_SNAPPING_MODES;
}>;
export type GRID_SNAPPING_MODES = Brand<number, "constants.GRID_SNAPPING_MODES">;

/**
 * A list of supported setup URL names
 */
export declare const SETUP_VIEWS: readonly ["auth", "license", "setup", "players", "join", "update"];
export type SETUP_VIEWS = ValueOf<typeof SETUP_VIEWS>;

/**
 * An Array of valid MacroAction scope values
 */
export declare const MACRO_SCOPES: readonly ["global", "actors", "actor"];
export type MACRO_SCOPES = ValueOf<typeof MACRO_SCOPES>;

/**
 * An enumeration of valid Macro types
 * @see {@link https://foundryvtt.com/article/macros/}
 */
export declare const MACRO_TYPES: Readonly<{
  /**
   * Complex and powerful macros which leverage the FVTT API through plain JavaScript to perform functions as simple or as advanced as you can imagine.
   */
  SCRIPT: "script";

  /**
   * Simple and easy to use, chat macros post pre-defined chat messages to the chat log when executed. All users can execute chat macros by default.
   */
  CHAT: "chat";
}>;
export type MACRO_TYPES = ValueOf<typeof MACRO_TYPES>;

/**
 * The allowed channels for audio playback.
 */
export declare const AUDIO_CHANNELS: Readonly<{
  music: "AUDIO.CHANNELS.MUSIC.label";
  environment: "AUDIO.CHANNELS.ENVIRONMENT.label";
  interface: "AUDIO.CHANNELS.INTERFACE.label";
}>;
export type AUDIO_CHANNELS = ValueOf<typeof AUDIO_CHANNELS>;

/**
 * The allowed playback modes for an audio Playlist
 * @see {@link https://foundryvtt.com/article/playlists/}
 */
export declare const PLAYLIST_MODES: Readonly<{
  /**
   * The playlist does not play on its own, only individual Sound tracks played as a soundboard.
   */
  DISABLED: -1 & PLAYLIST_MODES;

  /**
   * The playlist plays sounds one at a time in sequence.
   */
  SEQUENTIAL: 0 & PLAYLIST_MODES;

  /**
   * The playlist plays sounds one at a time in randomized order.
   */
  SHUFFLE: 1 & PLAYLIST_MODES;

  /**
   * The playlist plays all contained sounds at the same time.
   */
  SIMULTANEOUS: 2 & PLAYLIST_MODES;
}>;
export type PLAYLIST_MODES = Brand<number, "constants.PLAYLIST_MODES">;

/**
 * The available sort modes for an audio Playlist.
 * @defaultValue `"a"`
 * @see {@link https://foundryvtt.com/article/playlists/}
 */
export declare const PLAYLIST_SORT_MODES: Readonly<{
  /**
   * Sort sounds alphabetically.
   * @defaultValue
   */
  ALPHABETICAL: "a";

  /**
   * Sort sounds by manual drag-and-drop.
   */
  MANUAL: "m";
}>;
export type PLAYLIST_SORT_MODES = ValueOf<typeof PLAYLIST_SORT_MODES>;

/**
 * The available modes for searching within a DirectoryCollection
 */
export declare const DIRECTORY_SEARCH_MODES: Readonly<{
  FULL: "full";
  NAME: "name";
}>;
export type DIRECTORY_SEARCH_MODES = ValueOf<typeof DIRECTORY_SEARCH_MODES>;

/**
 * The allowed package types
 */
export declare const PACKAGE_TYPES: readonly ["world", "system", "module"];
export type PACKAGE_TYPES = ValueOf<typeof PACKAGE_TYPES>;

/**
 * Encode the reasons why a package may be available or unavailable for use
 */
export declare const PACKAGE_AVAILABILITY_CODES: Readonly<{
  /**
   * Package availability could not be determined
   */
  UNKNOWN: 0 & PACKAGE_AVAILABILITY_CODES;

  /**
   * The Package is verified to be compatible with the current core software build
   */
  VERIFIED: 1 & PACKAGE_AVAILABILITY_CODES;

  /**
   * Package is available for use, but not verified for the current core software build
   */
  UNVERIFIED_BUILD: 2 & PACKAGE_AVAILABILITY_CODES;

  /**
   * One or more installed system is incompatible with the Package.
   */
  UNVERIFIED_SYSTEM: 3 & PACKAGE_AVAILABILITY_CODES;

  /**
   * Package is available for use, but not verified for the current core software generation
   */
  UNVERIFIED_GENERATION: 4 & PACKAGE_AVAILABILITY_CODES;

  /**
   * The System that the Package relies on is not available
   */
  MISSING_SYSTEM: 5 & PACKAGE_AVAILABILITY_CODES;

  /**
   * A dependency of the Package is not available
   */
  MISSING_DEPENDENCY: 6 & PACKAGE_AVAILABILITY_CODES;

  /**
   * The Package is compatible with an older version of Foundry than the currently installed version
   */
  REQUIRES_CORE_DOWNGRADE: 7 & PACKAGE_AVAILABILITY_CODES;

  /**
   * The Package is compatible with a newer version of Foundry than the currently installed version, and that version is Stable
   */
  REQUIRES_CORE_UPGRADE_STABLE: 8 & PACKAGE_AVAILABILITY_CODES;

  /**
   * The Package is compatible with a newer version of Foundry than the currently installed version, and that version is not yet Stable
   */
  REQUIRES_CORE_UPGRADE_UNSTABLE: 9 & PACKAGE_AVAILABILITY_CODES;

  /**
   * A required dependency is not compatible with the current version of Foundry
   */
  REQUIRES_DEPENDENCY_UPDATE: 10 & PACKAGE_AVAILABILITY_CODES;
}>;
export type PACKAGE_AVAILABILITY_CODES = Brand<number, "constants.PACKAGE_AVAILABILITY_CODES">;

/**
 * A safe password string which can be displayed
 */
export declare const PASSWORD_SAFE_STRING: "••••••••••••••••";

/**
 * The allowed software update channels
 */
export declare const SOFTWARE_UPDATE_CHANNELS: Readonly<{
  /**
   * The Stable release channel
   */
  stable: "SETUP.UpdateStable";

  /**
   * The User Testing release channel
   */
  testing: "SETUP.UpdateTesting";

  /**
   * The Development release channel
   */
  development: "SETUP.UpdateDevelopment";

  /**
   * The Prototype release channel
   */
  prototype: "SETUP.UpdatePrototype";
}>;
export type SOFTWARE_UPDATE_CHANNELS = ValueOf<typeof SOFTWARE_UPDATE_CHANNELS>;

/**
 * The default sorting density for manually ordering child objects within a parent
 * @defaultValue `100000`
 */
export declare const SORT_INTEGER_DENSITY: number;

/**
 * The allowed types of a TableResult document
 * @see {@link https://foundryvtt.com/article/roll-tables/}
 */
export declare const TABLE_RESULT_TYPES: Readonly<{
  /**
   *  Plain text or HTML scripted entries which will be output to Chat.
   */
  TEXT: "text";

  /**
   * An in-World Document reference which will be linked to in the chat message.
   */
  DOCUMENT: "document";

  /**
   * A Compendium Pack reference which will be linked to in the chat message.
   * @deprecated "`CONST.TABLE_RESULT_TYPES.COMPENDIUM` is is deprecated in favor of {@linkcode CONST.TABLE_RESULT_TYPES.DOCUMENT}
   * due to the "compendium" being merged with the "document" type." (since v13, until v15)
   */
  get COMPENDIUM(): "pack";
}>;
export type TABLE_RESULT_TYPES = ValueOf<typeof TABLE_RESULT_TYPES>;

/**
 * The allowed formats of a Journal Entry Page.
 * @see {@link https://foundryvtt.com/article/journal/}
 */
export declare const JOURNAL_ENTRY_PAGE_FORMATS: Readonly<{
  /**
   * The page is formatted as HTML.
   */
  HTML: 1 & JOURNAL_ENTRY_PAGE_FORMATS;

  /**
   * The page is formatted as Markdown.
   */
  MARKDOWN: 2 & JOURNAL_ENTRY_PAGE_FORMATS;
}>;
export type JOURNAL_ENTRY_PAGE_FORMATS = Brand<number, "constants.JOURNAL_ENTRY_PAGE_FORMATS">;

/**
 * Define the valid anchor locations for a Tooltip displayed on a Placeable Object
 * @see {@linkcode foundry.helpers.interaction.TooltipManager}
 */
export declare const TEXT_ANCHOR_POINTS: Readonly<{
  /**
   * Anchor the tooltip to the center of the element.
   */
  CENTER: 0 & TEXT_ANCHOR_POINTS;

  /**
   * Anchor the tooltip to the bottom of the element.
   */
  BOTTOM: 1 & TEXT_ANCHOR_POINTS;

  /**
   * Anchor the tooltip to the top of the element.
   */
  TOP: 2 & TEXT_ANCHOR_POINTS;

  /**
   * Anchor the tooltip to the left of the element.
   */
  LEFT: 3 & TEXT_ANCHOR_POINTS;

  /**
   * Anchor the tooltip to the right of the element.
   */
  RIGHT: 4 & TEXT_ANCHOR_POINTS;
}>;
export type TEXT_ANCHOR_POINTS = Brand<number, "constants.TEXT_ANCHOR_POINTS">;

/**
 * Define the valid occlusion modes which a tile can use
 * @remarks Foundry leaves a comment in the middle of the object: "// ROOF: 2;  This mode is no longer supported so we don't use 2 for any other mode"
 * @see {@link https://foundryvtt.com/article/tiles/}
 */
export declare const OCCLUSION_MODES: Readonly<{
  /**
   * Turns off occlusion, making the tile never fade while tokens are under it.
   */
  NONE: 0 & OCCLUSION_MODES;

  /**
   * Causes the whole tile to fade when an actor token moves under it.
   * @defaultValue
   */
  FADE: 1 & OCCLUSION_MODES;

  /**
   * Causes the tile to reveal the background in the vicinity of an actor token under it. The radius is determined by the token's size.
   */
  RADIAL: 3 & OCCLUSION_MODES;

  /**
   * Causes the tile to be partially revealed based on the vision of the actor, which does not need to be under the tile to see what's beneath it.
   * This is useful for roofs on buildings where players could see through a window or door, viewing only a portion of what is obscured by the roof itself.
   */
  VISION: 4 & OCCLUSION_MODES;
}>;
export type OCCLUSION_MODES = Brand<number, "constants.OCCLUSION_MODES">;

/**
 * Alias for old tile occlusion modes definition
 * @remarks Foundry leaves a comment in the middle of the object: "// ROOF: 2;  This mode is no longer supported so we don't use 2 for any other mode"
 * @privateRemarks Foundry just does `export const TILE_OCCLUSION_MODES = OCCLUSION_MODES` but we have to be un-DRY if we want a different brand
 */
export declare const TILE_OCCLUSION_MODES: {
  /**
   * Turns off occlusion, making the tile never fade while tokens are under it.
   */
  NONE: 0 & TILE_OCCLUSION_MODES;

  /**
   * Causes the whole tile to fade when an actor token moves under it.
   * @defaultValue
   */
  FADE: 1 & TILE_OCCLUSION_MODES;

  /**
   * Causes the tile to reveal the background in the vicinity of an actor token under it. The radius is determined by the token's size.
   */
  RADIAL: 3 & TILE_OCCLUSION_MODES;

  /**
   * Causes the tile to be partially revealed based on the vision of the actor, which does not need to be under the tile to see what's beneath it.
   * This is useful for roofs on buildings where players could see through a window or door, viewing only a portion of what is obscured by the roof itself.
   */
  VISION: 4 & TILE_OCCLUSION_MODES;
};
export type TILE_OCCLUSION_MODES = Brand<number, "constants.TILE_OCCLUSION_MODES">;

/**
 * The occlusion modes that define the set of tokens that trigger occlusion.
 */
export declare const TOKEN_OCCLUSION_MODES: Readonly<{
  /**
   * Owned tokens that aren't hidden.
   */
  OWNED: 0x1 & TOKEN_OCCLUSION_MODES;

  /**
   * Controlled tokens.
   */
  CONTROLLED: 0x2 & TOKEN_OCCLUSION_MODES;

  /**
   * Hovered tokens that are visible.
   */
  HOVERED: 0x4 & TOKEN_OCCLUSION_MODES;

  /**
   * Highlighted tokens that are visible.
   */
  HIGHLIGHTED: 0x8 & TOKEN_OCCLUSION_MODES;

  /**
   * All visible tokens.
   */
  VISIBLE: 0x10 & TOKEN_OCCLUSION_MODES;
}>;
export type TOKEN_OCCLUSION_MODES = Brand<number, "constants.TOKEN_OCCLUSION_MODES">;

/**
 * Describe the various thresholds of token control upon which to show certain pieces of information
 * @see {@link https://foundryvtt.com/article/tokens/}
 */
export declare const TOKEN_DISPLAY_MODES: Readonly<{
  /**
   * No information is displayed.
   */
  NONE: 0 & TOKEN_DISPLAY_MODES;

  /**
   * Displayed when the token is controlled.
   */
  CONTROL: 10 & TOKEN_DISPLAY_MODES;

  /**
   * Displayed when hovered by a GM or a user who owns the actor.
   */
  OWNER_HOVER: 20 & TOKEN_DISPLAY_MODES;

  /**
   * Displayed when hovered by any user.
   */
  HOVER: 30 & TOKEN_DISPLAY_MODES;

  /**
   * Always displayed for a GM or for a user who owns the actor.
   */
  OWNER: 40 & TOKEN_DISPLAY_MODES;

  /**
   * Always displayed for everyone.
   */
  ALWAYS: 50 & TOKEN_DISPLAY_MODES;
}>;
export type TOKEN_DISPLAY_MODES = Brand<number, "constants.TOKEN_DISPLAY_MODES">;

/**
 * The allowed Token disposition types
 * @see {@link https://foundryvtt.com/article/tokens/}
 */
export declare const TOKEN_DISPOSITIONS: Readonly<{
  /**
   * Displayed with a purple borders for owners and with no borders for others (and no pointer change).
   */
  SECRET: -2 & TOKEN_DISPOSITIONS;

  /**
   * Displayed as an enemy with a red border.
   */
  HOSTILE: -1 & TOKEN_DISPOSITIONS;

  /**
   * Displayed as neutral with a yellow border.
   */
  NEUTRAL: 0 & TOKEN_DISPOSITIONS;

  /**
   * Displayed as an ally with a cyan border.
   */
  FRIENDLY: 1 & TOKEN_DISPOSITIONS;
}>;
export type TOKEN_DISPOSITIONS = Brand<number, "constants.TOKEN_DISPOSITIONS">;

/**
 * The allowed token turn markers modes.
 */
export declare const TOKEN_TURN_MARKER_MODES: Readonly<{
  /**
   * The turn marker is disabled for this token.
   */
  DISABLED: 0 & TOKEN_TURN_MARKER_MODES;

  /**
   * The turn marker for this token is using the combat tracker settings (which could be disabled).
   */
  DEFAULT: 1 & TOKEN_TURN_MARKER_MODES;

  /**
   * The turn marker is using the token settings (unless the combat tracker turn marker setting is disabled)
   */
  CUSTOM: 2 & TOKEN_TURN_MARKER_MODES;
}>;
export type TOKEN_TURN_MARKER_MODES = Brand<number, "constants.TOKEN_TURN_MARKER_MODES">;

/**
 * The possible shapes of Tokens.
 */
export declare const TOKEN_SHAPES: Readonly<{
  /**
   * Ellipse (Variant 1)
   */
  ELLIPSE_1: 0 & TOKEN_SHAPES;

  /**
   * Ellipse (Variant 2)
   */
  ELLIPSE_2: 1 & TOKEN_SHAPES;

  /**
   * Trapezoid (Variant 1)
   */
  TRAPEZOID_1: 2 & TOKEN_SHAPES;

  /**
   * Trapezoid (Variant 2)
   */
  TRAPEZOID_2: 3 & TOKEN_SHAPES;

  /**
   * Rectangle (Variant 1)
   */
  RECTANGLE_1: 4 & TOKEN_SHAPES;

  /**
   * Rectangle (Variant 2)
   */
  RECTANGLE_2: 5 & TOKEN_SHAPES;
}>;
export type TOKEN_SHAPES = Brand<number, "constants.TOKEN_SHAPES">;

/**
 * Define the allowed User permission levels.
 * Each level is assigned a value in ascending order. Higher levels grant more permissions.
 * @see {@link https://foundryvtt.com/article/users/}
 */
export declare const USER_ROLES: Readonly<{
  /**
   * The User is blocked from taking actions in Foundry Virtual Tabletop.
   * You can use this role to temporarily or permanently ban a user from joining the game.
   */
  NONE: 0 & USER_ROLES;

  /**
   * The User is able to join the game with permissions available to a standard player.
   * They cannot take some more advanced actions which require Trusted permissions, but they have the basic
   * functionalities needed to operate in the virtual tabletop.
   */
  PLAYER: 1 & USER_ROLES;

  /**
   * Similar to the Player role, except a Trusted User has the ability to perform some more advanced actions
   * like create drawings, measured templates, or even to (optionally) upload media files to the server.
   */
  TRUSTED: 2 & USER_ROLES;

  /**
   * A special User who has many of the same in-game controls as a Game Master User, but does not have the ability
   * to perform administrative actions like changing User roles or modifying World-level settings.
   */
  ASSISTANT: 3 & USER_ROLES;

  /**
   * A special User who has administrative control over this specific World.
   * Game Masters behave quite differently than Players in that they have the ability to see all Documents and
   * Objects within the world as well as the capability to configure World settings.
   */
  GAMEMASTER: 4 & USER_ROLES;
}>;
export type USER_ROLES = Brand<number, "constants.USER_ROLES">;

/**
 * Invert the User Role mapping to recover role names from a role integer
 */
export declare const USER_ROLE_NAMES: Readonly<{
  /**
   * The User is blocked from taking actions in Foundry Virtual Tabletop.
   * You can use this role to temporarily or permanently ban a user from joining the game.
   */
  "0": "NONE";

  /**
   * The User is able to join the game with permissions available to a standard player.
   * They cannot take some more advanced actions which require Trusted permissions, but they have the basic
   * functionalities needed to operate in the virtual tabletop.
   */
  "1": "PLAYER";

  /**
   * Similar to the Player role, except a Trusted User has the ability to perform some more advanced actions
   * like create drawings, measured templates, or even to (optionally) upload media files to the server.
   */
  "2": "TRUSTED";

  /**
   * A special User who has many of the same in-game controls as a Game Master User, but does not have the
   * ability to perform administrative actions like changing User roles or modifying World-level settings.
   */
  "3": "ASSISTANT";

  /**
   * A special User who has administrative control over this specific World.
   * Game Masters behave quite differently than Players in that they have the ability to see all Documents
   * and Objects within the world as well as the capability to configure World settings.
   */
  "4": "GAMEMASTER";
}>;
export type USER_ROLE_NAMES = ValueOf<typeof USER_ROLE_NAMES>;

/**
 * An enumeration of the allowed types for a MeasuredTemplate embedded document
 * @see {@link https://foundryvtt.com/article/measurement/}
 */
export declare const MEASURED_TEMPLATE_TYPES: Readonly<{
  /**
   * Circular templates create a radius around the starting point.
   */
  CIRCLE: "circle";

  /**
   * Cones create an effect in the shape of a triangle or pizza slice from the starting point.
   */
  CONE: "cone";

  /**
   * A rectangle uses the origin point as one of the corners, treating the origin as being inside of the rectangle's area.
   */
  RECTANGLE: "rect";

  /**
   * A ray creates a single line that is one square in width and as long as you want it to be.
   */
  RAY: "ray";
}>;
export type MEASURED_TEMPLATE_TYPES = ValueOf<typeof MEASURED_TEMPLATE_TYPES>;

export interface UserPermission {
  disableGM: boolean;
  hint: string;
  label: string;
  defaultRole: USER_ROLES;
}

/**
 * Define the recognized User capabilities which individual Users or role levels may be permitted to perform
 */
export declare const USER_PERMISSIONS: DeepReadonly<{
  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.ActorCreate",
   *    hint: "PERMISSION.ActorCreateHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.ASSISTANT
   * }
   * ```
   */
  ACTOR_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.BroadcastAudio",
   *    hint: "PERMISSION.BroadcastAudioHint",
   *    disableGM: true,
   *    defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  BROADCAST_AUDIO: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.BroadcastVideo",
   *    hint: "PERMISSION.BroadcastVideoHint",
   *    disableGM: true,
   *    defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  BROADCAST_VIDEO: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *   label: "PERMISSION.CardsCreate",
   *   hint: "PERMISSION.CardsCreateHint",
   *   disableGM: false,
   *   defaultRole: USER_ROLES.ASSISTANT
   * }
   * ```
   */

  CARDS_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.DrawingCreate",
   *    hint: "PERMISSION.DrawingCreateHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  DRAWING_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.ItemCreate",
   *    hint: "PERMISSION.ItemCreateHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.ASSISTANT
   * }
   * ```
   */
  ITEM_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.FilesBrowse",
   *    hint: "PERMISSION.FilesBrowseHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  FILES_BROWSE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.FilesUpload",
   *    hint: "PERMISSION.FilesUploadHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.ASSISTANT
   * }
   * ```
   */
  FILES_UPLOAD: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.JournalCreate"
   *    hint: "PERMISSION.JournalCreateHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  JOURNAL_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.MacroScript",
   *    hint: "PERMISSION.MacroScriptHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.PLAYER
   * }
   * ```
   */
  MACRO_SCRIPT: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.ManualRolls",
   *    hint: "PERMISSION.ManualRollsHint",
   *    disableGM: true,
   *    defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  MANUAL_ROLLS: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.MessageWhisper",
   *    hint: "PERMISSION.MessageWhisperHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.PLAYER
   * }
   * ```
   */
  MESSAGE_WHISPER: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.NoteCreate",
   *    hint: "PERMISSION.NoteCreateHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  NOTE_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *   label: "PERMISSION.NoteCreate",
   *   hint: "PERMISSION.NoteCreateHint",
   *   disableGM: false,
   *   defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  PING_CANVAS: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *   label: "PERMISSION.PlaylistCreate",
   *   hint: "PERMISSION.PlaylistCreateHint",
   *   disableGM: false,
   *   defaultRole: USER_ROLES.ASSISTANT
   * }
   * ```
   */
  PLAYLIST_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.SettingsModify",
   *    hint: "PERMISSION.SettingsModifyHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.ASSISTANT
   * }
   * ```
   */
  SETTINGS_MODIFY: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.ShowCursor",
   *    hint: "PERMISSION.ShowCursorHint",
   *    disableGM: true,
   *    defaultRole: USER_ROLES.PLAYER
   * }
   * ```
   */
  SHOW_CURSOR: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.ShowRuler",
   *    hint: "PERMISSION.ShowRulerHint",
   *    disableGM: true,
   *    defaultRole: USER_ROLES.PLAYER
   * }
   * ```
   */
  SHOW_RULER: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.TemplateCreate",
   *    hint: "PERMISSION.TemplateCreateHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.PLAYER
   * }
   * ```
   */
  TEMPLATE_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.TokenCreate",
   *    hint: "PERMISSION.TokenCreateHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.ASSISTANT
   * }
   * ```
   */
  TOKEN_CREATE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.TokenDelete",
   *    hint: "PERMISSION.TokenDeleteHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.ASSISTANT
   * }
   * ```
   */
  TOKEN_DELETE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.TokenConfigure",
   *    hint: "PERMISSION.TokenConfigureHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.TRUSTED
   * }
   * ```
   */
  TOKEN_CONFIGURE: UserPermission;

  /**
   * @defaultValue
   * ```typescript
   * {
   *    label: "PERMISSION.WallDoors",
   *    hint: "PERMISSION.WallDoorsHint",
   *    disableGM: false,
   *    defaultRole: USER_ROLES.PLAYER
   * }
   * ```
   */
  WALL_DOORS: UserPermission;

  /**
   * @defaultValue
   * ```ts
   * {
   *   label: "PERMISSION.QueryUser",
   *   hint: "PERMISSION.QueryUserHint",
   *   disableGM: false,
   *   defaultRole: USER_ROLES.PLAYER
   * }
   * ```
   */
  QUERY_USER: UserPermission;
}>;
export type USER_PERMISSIONS = keyof typeof USER_PERMISSIONS;

/**
 * The allowed directions of effect that a Wall can have
 * @see {@link https://foundryvtt.com/article/walls/}
 */
export declare const WALL_DIRECTIONS: Readonly<{
  /**
   * The wall collides from both directions.
   */
  BOTH: 0 & WALL_DIRECTIONS;

  /**
   * The wall collides only when a ray strikes its left side.
   */
  LEFT: 1 & WALL_DIRECTIONS;

  /**
   * The wall collides only when a ray strikes its right side.
   */
  RIGHT: 2 & WALL_DIRECTIONS;
}>;
export type WALL_DIRECTIONS = Brand<number, "constants.WALL_DIRECTIONS">;

/**
 * The allowed door types which a Wall may contain
 * @see {@link https://foundryvtt.com/article/walls/}
 */
export declare const WALL_DOOR_TYPES: Readonly<{
  /**
   * The wall does not contain a door.
   */
  NONE: 0 & WALL_DOOR_TYPES;

  /**
   *  The wall contains a regular door.
   */
  DOOR: 1 & WALL_DOOR_TYPES;

  /**
   * The wall contains a secret door.
   */
  SECRET: 2 & WALL_DOOR_TYPES;
}>;
export type WALL_DOOR_TYPES = Brand<number, "constants.WALL_DOOR_TYPES">;

/**
 * The allowed door states which may describe a Wall that contains a door
 * @see {@link https://foundryvtt.com/article/walls/}
 */
export declare const WALL_DOOR_STATES: Readonly<{
  /**
   * The door is closed.
   */
  CLOSED: 0 & WALL_DOOR_STATES;

  /**
   * The door is open.
   */
  OPEN: 1 & WALL_DOOR_STATES;

  /**
   * The door is closed and locked.
   */
  LOCKED: 2 & WALL_DOOR_STATES;
}>;
export type WALL_DOOR_STATES = Brand<number, "constants.WALL_DOOR_STATES">;

/**
 * The possible ways to interact with a door
 */
export declare const WALL_DOOR_INTERACTIONS: readonly ["open", "close", "lock", "unlock", "test"];
export type WALL_DOOR_INTERACTIONS = ValueOf<typeof WALL_DOOR_INTERACTIONS>;

/**
 * The wall properties which restrict the way interaction occurs with a specific wall
 */
export declare const WALL_RESTRICTION_TYPES: readonly ["light", "sight", "sound", "move"];
export type WALL_RESTRICTION_TYPES = ValueOf<typeof WALL_RESTRICTION_TYPES>;

/**
 * The types of sensory collision which a Wall may impose
 * @see {@link https://foundryvtt.com/article/walls/}
 */
export declare const WALL_SENSE_TYPES: Readonly<{
  /**
   * Senses do not collide with this wall.
   */
  NONE: 0 & WALL_SENSE_TYPES;

  /**
   * Senses collide with this wall.
   */
  LIMITED: 10 & WALL_SENSE_TYPES;

  /**
   * Senses collide with the second intersection, bypassing the first.
   */
  NORMAL: 20 & WALL_SENSE_TYPES;

  /**
   * Senses bypass the wall within a certain proximity threshold.
   */
  PROXIMITY: 30 & WALL_SENSE_TYPES;

  /**
   * Senses bypass the wall outside a certain proximity threshold.
   */
  DISTANCE: 40 & WALL_SENSE_TYPES;
}>;
export type WALL_SENSE_TYPES = Brand<number, "constants.WALL_SENSE_TYPES">;

/**
 * The types of movement collision which a Wall may impose
 * @see {@link https://foundryvtt.com/article/walls/}
 * @privateRemarks Foundry just does `NONE: WALL_SENSE_TYPES.NONE` etc but we want to have a separate brand
 */
export declare const WALL_MOVEMENT_TYPES: Readonly<{
  /**
   * Movement does not collide with this wall.
   */
  NONE: 0 & WALL_MOVEMENT_TYPES;

  /**
   * Movement collides with this wall.
   */
  NORMAL: 20 & WALL_MOVEMENT_TYPES;
}>;
export type WALL_MOVEMENT_TYPES = Brand<number, "constants.WALL_MOVEMENT_TYPES">;

/**
 * The possible precedence values a Keybinding might run in
 * @see {@link https://foundryvtt.com/article/keybinds/}
 */
export declare const KEYBINDING_PRECEDENCE: Readonly<{
  /**
   * Runs in the first group along with other PRIORITY keybindings.
   */
  PRIORITY: 0 & KEYBINDING_PRECEDENCE;

  /**
   * Runs after the PRIORITY group along with other NORMAL keybindings.
   */
  NORMAL: 1 & KEYBINDING_PRECEDENCE;

  /**
   * Runs in the last group along with other DEFERRED keybindings.
   */
  DEFERRED: 2 & KEYBINDING_PRECEDENCE;
}>;
export type KEYBINDING_PRECEDENCE = Brand<number, "constants.KEYBINDING_PRECEDENCE">;

/**
 * Directories in the public storage path.
 */
export const FILE_PICKER_PUBLIC_DIRS: readonly ["cards", "css", "fonts", "icons", "lang", "scripts", "sounds", "ui"];
export type FILE_PICKER_PUBLIC_DIRS = ValueOf<typeof FILE_PICKER_PUBLIC_DIRS>;

/**
 * The allowed set of HTML template extensions
 */
export declare const HTML_FILE_EXTENSIONS: Readonly<{
  handlebars: "text/x-handlebars-template";
  hbs: "text/x-handlebars-template";
  html: "text/html";
}>;
export declare type HTML_FILE_EXTENSIONS = keyof typeof HTML_FILE_EXTENSIONS;

/**
 * The supported file extensions for image-type files, and their corresponding mime types.
 */
export declare const IMAGE_FILE_EXTENSIONS: Readonly<{
  apng: "image/apng";
  avif: "image/avif";
  bmp: "image/bmp";
  gif: "image/gif";
  jpeg: "image/jpeg";
  jpg: "image/jpeg";
  png: "image/png";
  svg: "image/svg+xml";
  tiff: "image/tiff";
  webp: "image/webp";
}>;
export type IMAGE_FILE_EXTENSIONS = keyof typeof IMAGE_FILE_EXTENSIONS;

/**
 * The supported file extensions for video-type files, and their corresponding mime types.
 */
export declare const VIDEO_FILE_EXTENSIONS: Readonly<{
  m4v: "video/mp4";
  mp4: "video/mp4";
  ogv: "video/ogg";
  webm: "video/webm";
}>;
export type VIDEO_FILE_EXTENSIONS = keyof typeof VIDEO_FILE_EXTENSIONS;

/**
 * The supported file extensions for audio-type files, and their corresponding mime types.
 */
export declare const AUDIO_FILE_EXTENSIONS: Readonly<{
  aac: "audio/aac";
  flac: "audio/flac";
  m4a: "audio/mp4";
  mid: "audio/midi";
  mp3: "audio/mpeg";
  ogg: "audio/ogg";
  opus: "audio/opus";
  wav: "audio/wav";
  webm: "audio/webm";
}>;
export type AUDIO_FILE_EXTENSIONS = keyof typeof AUDIO_FILE_EXTENSIONS;

/**
 * The supported file extensions for text files, and their corresponding mime types.
 */
export declare const TEXT_FILE_EXTENSIONS: Readonly<{
  csv: "text/csv";
  json: "application/json";
  md: "text/markdown";
  pdf: "application/pdf";
  tsv: "text/tab-separated-values";
  txt: "text/plain";
  xml: "application/xml";
  yml: "application/yaml";
  yaml: "application/yaml";
}>;
export type TEXT_FILE_EXTENSIONS = keyof typeof TEXT_FILE_EXTENSIONS;

/**
 * Supported file extensions for font files, and their corresponding mime types.
 */
export declare const FONT_FILE_EXTENSIONS: Readonly<{
  otf: "font/otf";
  ttf: "font/ttf";
  woff: "font/woff";
  woff2: "font/woff2";
}>;
export type FONT_FILE_EXTENSIONS = keyof typeof FONT_FILE_EXTENSIONS;

/**
 * Supported file extensions for 3D files, and their corresponding mime types.
 */
export declare const GRAPHICS_FILE_EXTENSIONS: Readonly<{
  fbx: "application/octet-stream";
  glb: "model/gltf-binary";
  gltf: "model/gltf+json";
  mtl: "model/mtl";
  obj: "model/obj";
  stl: "model/stl";
  usdz: "model/vnd.usdz+zip";
}>;
export type GRAPHICS_FILE_EXTENSIONS = keyof typeof GRAPHICS_FILE_EXTENSIONS;

/**
 * @privateRemarks Video is spread in after audio, so its `ogg` and `webm` keys override
 */
interface _UPLOADABLE_FILE_EXTENSIONS
  extends Identity<typeof IMAGE_FILE_EXTENSIONS>,
    Omit<typeof AUDIO_FILE_EXTENSIONS, "ogg" | "webm">,
    Identity<typeof VIDEO_FILE_EXTENSIONS>,
    Identity<typeof TEXT_FILE_EXTENSIONS>,
    Identity<typeof FONT_FILE_EXTENSIONS>,
    Identity<typeof GRAPHICS_FILE_EXTENSIONS> {}

export declare const UPLOADABLE_FILE_EXTENSIONS: Readonly<_UPLOADABLE_FILE_EXTENSIONS>;
export type UPLOADABLE_FILE_EXTENSIONS = keyof typeof UPLOADABLE_FILE_EXTENSIONS;

/**
 * An enumeratio