/** * @license * Copyright 2019 Google LLC * SPDX-License-Identifier: Apache-2.0 */ /** * @fileoverview Type definitions for Blockly. * @author samelh@google.com (Sam El-Husseini) */ export = Blockly; declare module Blockly { interface BlocklyOptions { toolbox?: Blockly.utils.toolbox.ToolboxDefinition; readOnly?: boolean; trashcan?: boolean; maxInstances?: {[type: string]: number;}; maxTrashcanContents?: number; collapse?: boolean; comments?: boolean; disable?: boolean; sounds?: boolean; rtl?: boolean; horizontalLayout?: boolean; toolboxPosition?: string; css?: boolean; oneBasedIndex?: boolean; media?: string; theme?: Blockly.Theme | BlocklyThemeOptions; move?: { scrollbars?: boolean; drag?: boolean; wheel?: boolean; }; grid?: { spacing?: number; colour?: string; length?: number; snap?: boolean; }; zoom?: { controls?: boolean; wheel?: boolean; startScale?: number; maxScale?: number; minScale?: number; scaleSpeed?: number; pinch?: boolean; }; renderer?: string; parentWorkspace?: Blockly.WorkspaceSvg; } interface BlocklyThemeOptions { base?: string; blockStyles?: {[blocks: string]: Blockly.Theme.BlockStyle;}; categoryStyles?: {[category: string]: Blockly.Theme.CategoryStyle;}; componentStyles?: {[component: string]: any;}; fontStyle?: Blockly.Theme.FontStyle; startHats?: boolean; } /** * Set the Blockly locale. * Note: this method is only available in the npm release of Blockly. * @param {!Object} msg An object of Blockly message strings in the desired * language. */ function setLocale(msg: {[key: string]: string;}): void; } declare module Blockly.utils { interface Metrics { viewHeight: number; viewWidth: number; contentHeight: number; contentWidth: number; viewTop: number; viewLeft: number; contentTop: number; contentLeft: number; absoluteTop: number; absoluteLeft: number; svgHeight?: number; svgWidth?: number; toolboxWidth?: number; toolboxHeight?: number; flyoutWidth?: number; flyoutHeight?: number; toolboxPosition?: number; } } declare module Block { /** * @typedef {{ * text:?string, * pinned:boolean, * size:Size * }} */ interface CommentModel { text: string; pinned: boolean; size: Size } /** * The language-neutral ID given to the collapsed input. * @const {string} */ var COLLAPSED_INPUT_NAME: any /*missing*/; /** * The language-neutral ID given to the collapsed field. * @const {string} */ var COLLAPSED_FIELD_NAME: any /*missing*/; } declare module BlockSvg { /** * Constant for identifying rows that are to be rendered inline. * Don't collide with Blockly.inputTypes. * @const */ var INLINE: any /*missing*/; /** * ID to give the "collapsed warnings" warning. Allows us to remove the * "collapsed warnings" warning without removing any warnings that belong to * the block. * @type {string} * @const */ var COLLAPSED_WARNING_ID: string; } declare module exports { /** * Blockly core version. * This constant is overridden by the build script (npm run build) to the value * of the version in package.json. This is done by the Closure Compiler in the * buildCompressed gulp task. * For local builds, you can pass --define='Blockly.VERSION=X.Y.Z' to the * compiler to override this constant. * @define {string} * @alias Blockly.VERSION */ var VERSION: any /*missing*/; /** * Copy a block or workspace comment onto the local clipboard. * @param {!ICopyable} toCopy Block or Workspace Comment to be copied. * @package * @alias Blockly.copy */ function copy(toCopy: ICopyable): void; /** * Paste a block or workspace comment on to the main workspace. * @return {boolean} True if the paste was successful, false otherwise. * @package * @alias Blockly.paste */ function paste(): boolean; /** * Duplicate this block and its children, or a workspace comment. * @param {!ICopyable} toDuplicate Block or Workspace Comment to be * copied. * @package * @alias Blockly.duplicate */ function duplicate(toDuplicate: ICopyable): void; /** * Returns the main workspace. Returns the last used main workspace (based on * focus). Try not to use this function, particularly if there are multiple * Blockly instances on a page. * @return {!Workspace} The main workspace. * @alias Blockly.getMainWorkspace */ function getMainWorkspace(): Workspace; /** * Set the parent container. This is the container element that the WidgetDiv, * DropDownDiv, and Tooltip are rendered into the first time `Blockly.inject` * is called. * This method is a NOP if called after the first ``Blockly.inject``. * @param {!Element} container The container element. * @alias Blockly.setParentContainer */ function setParentContainer(container: Element): void; /** * @see colour.hueToHex * @deprecated Use Blockly.utils.colour.hueToHex (September 2021). * @alias Blockly.hueToHex */ var hueToHex: any /*missing*/; /** * @see browserEvents.bind * @alias Blockly.bindEvent_ */ var bindEvent_: any /*missing*/; /** * @see browserEvents.unbind * @alias Blockly.unbindEvent_ */ var unbindEvent_: any /*missing*/; /** * @see browserEvents.conditionalBind * @alias Blockly.bindEventWithChecks_ */ var bindEventWithChecks_: any /*missing*/; /** * @see constants.ALIGN.LEFT * @alias Blockly.ALIGN_LEFT */ var ALIGN_LEFT: any /*missing*/; /** * @see constants.ALIGN.CENTRE * @alias Blockly.ALIGN_CENTRE */ var ALIGN_CENTRE: any /*missing*/; /** * @see constants.ALIGN.RIGHT * @alias Blockly.ALIGN_RIGHT */ var ALIGN_RIGHT: any /*missing*/; /** * @see common.svgResize */ var svgResize: any /*missing*/; /** * @see ConnectionType.INPUT_VALUE * @alias Blockly.INPUT_VALUE */ var INPUT_VALUE: any /*missing*/; /** * @see ConnectionType.OUTPUT_VALUE * @alias Blockly.OUTPUT_VALUE */ var OUTPUT_VALUE: any /*missing*/; /** * @see ConnectionType.NEXT_STATEMENT * @alias Blockly.NEXT_STATEMENT */ var NEXT_STATEMENT: any /*missing*/; /** * @see ConnectionType.PREVIOUS_STATEMENT * @alias Blockly.PREVIOUS_STATEMENT */ var PREVIOUS_STATEMENT: any /*missing*/; /** * @see inputTypes.DUMMY_INPUT * @alias Blockly.DUMMY_INPUT */ var DUMMY_INPUT: any /*missing*/; /** * @see toolbox.Position.TOP * @alias Blockly.TOOLBOX_AT_TOP */ var TOOLBOX_AT_TOP: any /*missing*/; /** * @see toolbox.Position.BOTTOM * @alias Blockly.TOOLBOX_AT_BOTTOM */ var TOOLBOX_AT_BOTTOM: any /*missing*/; /** * @see toolbox.Position.LEFT * @alias Blockly.TOOLBOX_AT_LEFT */ var TOOLBOX_AT_LEFT: any /*missing*/; /** * @see toolbox.Position.RIGHT * @alias Blockly.TOOLBOX_AT_RIGHT */ var TOOLBOX_AT_RIGHT: any /*missing*/; /** @deprecated Use Blockly.ConnectionType instead. */ var connectionTypes: any /*missing*/; } declare module Bubble { /** * Width of the border around the bubble. */ var BORDER_WIDTH: any /*missing*/; /** * Determines the thickness of the base of the arrow in relation to the size * of the bubble. Higher numbers result in thinner arrows. */ var ARROW_THICKNESS: any /*missing*/; /** * The number of degrees that the arrow bends counter-clockwise. */ var ARROW_ANGLE: any /*missing*/; /** * The sharpness of the arrow's bend. Higher numbers result in smoother arrows. */ var ARROW_BEND: any /*missing*/; /** * Distance between arrow point and anchor point. */ var ANCHOR_RADIUS: any /*missing*/; /** * Create the text for a non editable bubble. * @param {string} text The text to display. * @return {!SVGTextElement} The top-level node of the text. * @package */ function textToDom(text: string): SVGTextElement; /** * Creates a bubble that can not be edited. * @param {!SVGTextElement} paragraphElement The text element for the non * editable bubble. * @param {!BlockSvg} block The block that the bubble is attached to. * @param {!Coordinate} iconXY The coordinate of the icon. * @return {!Bubble} The non editable bubble. * @package */ function createNonEditableBubble(paragraphElement: SVGTextElement, block: BlockSvg, iconXY: Coordinate): Bubble; } declare module exports { /** * All of the connections on blocks that are currently being dragged. * @type {!Array} */ var draggingConnections: Connection[]; } declare module ComponentManager { class Capability extends Capability__Class { } /** Fake class which should be extended to avoid inheriting static properties */ class Capability__Class { /** * A name with the capability of the element stored in the generic. * @param {string} name The name of the component capability. * @constructor * @template T */ constructor(name: string); } /** * An object storing component information. * @typedef {{ * component: !IComponent, * capabilities: ( * !Array> * ), * weight: number * }} */ interface ComponentDatum { component: IComponent; capabilities: string|ComponentManager.Capability[]; weight: number } } declare module ComponentManager.Capability { /** @type {!ComponentManager.Capability} */ var POSITIONABLE: ComponentManager.Capability; /** @type {!ComponentManager.Capability} */ var DRAG_TARGET: ComponentManager.Capability; /** @type {!ComponentManager.Capability} */ var DELETE_AREA: ComponentManager.Capability; /** @type {!ComponentManager.Capability} */ var AUTOHIDEABLE: ComponentManager.Capability; } declare module Connection { /** * Constants for checking whether two connections are compatible. */ var CAN_CONNECT: any /*missing*/; /** * Returns the connection (starting at the startBlock) which will accept * the given connection. This includes compatible connection types and * connection checks. * @param {!Block} startBlock The block on which to start the search. * @param {!Connection} orphanConnection The connection that is looking * for a home. * @return {?Connection} The suitable connection point on the chain of * blocks, or null. */ function getConnectionForOrphanedConnection(startBlock: Block, orphanConnection: Connection): Connection; } declare module ConnectionDB { /** * Initialize a set of connection DBs for a workspace. * @param {!IConnectionChecker} checker The workspace's * connection checker, used to decide if connections are valid during a * drag. * @return {!Array} Array of databases. */ function init(checker: IConnectionChecker): ConnectionDB[]; } declare module ContextMenuRegistry { /** * Where this menu item should be rendered. If the menu item should be rendered * in multiple scopes, e.g. on both a block and a workspace, it should be * registered for each scope. * @enum {string} */ enum ScopeType { BLOCK, WORKSPACE } /** * The actual workspace/block where the menu is being rendered. This is passed * to callback and displayText functions that depend on this information. * @typedef {{ * block: (BlockSvg|undefined), * workspace: (WorkspaceSvg|undefined) * }} */ interface Scope { block: BlockSvg|any /*undefined*/; workspace: WorkspaceSvg|any /*undefined*/ } /** * A menu item as entered in the registry. * @typedef {{ * callback: function(!ContextMenuRegistry.Scope), * scopeType: !ContextMenuRegistry.ScopeType, * displayText: ((function(!ContextMenuRegistry.Scope):string)|string), * preconditionFn: function(!ContextMenuRegistry.Scope):string, * weight: number, * id: string * }} */ interface RegistryItem { callback: { (_0: ContextMenuRegistry.Scope): any /*missing*/ }; scopeType: ContextMenuRegistry.ScopeType; displayText: { (_0: ContextMenuRegistry.Scope): string }|string; preconditionFn: { (_0: ContextMenuRegistry.Scope): string }; weight: number; id: string } /** * A menu item as presented to contextmenu.js. * @typedef {{ * text: string, * enabled: boolean, * callback: function(!ContextMenuRegistry.Scope), * scope: !ContextMenuRegistry.Scope, * weight: number * }} */ interface ContextMenuOption { text: string; enabled: boolean; callback: { (_0: ContextMenuRegistry.Scope): any /*missing*/ }; scope: ContextMenuRegistry.Scope; weight: number } /** * Singleton instance of this class. All interactions with this class should be * done on this object. * @type {?ContextMenuRegistry} */ var registry: ContextMenuRegistry; } declare module DropDownDiv { /** * Arrow size in px. Should match the value in CSS * (need to position pre-render). * @type {number} * @const */ var ARROW_SIZE: number; /** * Drop-down border size in px. Should match the value in CSS (need to position * the arrow). * @type {number} * @const */ var BORDER_SIZE: number; /** * Amount the arrow must be kept away from the edges of the main drop-down div, * in px. * @type {number} * @const */ var ARROW_HORIZONTAL_PADDING: number; /** * Amount drop-downs should be padded away from the source, in px. * @type {number} * @const */ var PADDING_Y: number; /** * Length of animations in seconds. * @type {number} * @const */ var ANIMATION_TIME: number; /** * Dropdown bounds info object used to encapsulate sizing information about a * bounding element (bounding box and width/height). * @typedef {{ * top:number, * left:number, * bottom:number, * right:number, * width:number, * height:number * }} */ interface BoundsInfo { top: number; left: number; bottom: number; right: number; width: number; height: number } /** * Dropdown position metrics. * @typedef {{ * initialX:number, * initialY:number, * finalX:number, * finalY:number, * arrowX:?number, * arrowY:?number, * arrowAtTop:?boolean, * arrowVisible:boolean * }} */ interface PositionMetrics { initialX: number; initialY: number; finalX: number; finalY: number; arrowX: number; arrowY: number; arrowAtTop: boolean; arrowVisible: boolean } /** * Create and insert the DOM element for this div. * @package */ function createDom(): void; /** * Set an element to maintain bounds within. Drop-downs will appear * within the box of this element if possible. * @param {?Element} boundsElement Element to bind drop-down to. */ function setBoundsElement(boundsElement: Element): void; /** * Provide the div for inserting content into the drop-down. * @return {!Element} Div to populate with content. */ function getContentDiv(): Element; /** * Clear the content of the drop-down. */ function clearContent(): void; /** * Set the colour for the drop-down. * @param {string} backgroundColour Any CSS colour for the background. * @param {string} borderColour Any CSS colour for the border. */ function setColour(backgroundColour: string, borderColour: string): void; /** * Shortcut to show and place the drop-down with positioning determined * by a particular block. The primary position will be below the block, * and the secondary position above the block. Drop-down will be * constrained to the block's workspace. * @param {!Field} field The field showing the drop-down. * @param {!BlockSvg} block Block to position the drop-down around. * @param {Function=} opt_onHide Optional callback for when the drop-down is * hidden. * @param {number=} opt_secondaryYOffset Optional Y offset for above-block * positioning. * @return {boolean} True if the menu rendered below block; false if above. */ function showPositionedByBlock(field: Field, block: BlockSvg, opt_onHide?: Function, opt_secondaryYOffset?: number): boolean; /** * Shortcut to show and place the drop-down with positioning determined * by a particular field. The primary position will be below the field, * and the secondary position above the field. Drop-down will be * constrained to the block's workspace. * @param {!Field} field The field to position the dropdown against. * @param {Function=} opt_onHide Optional callback for when the drop-down is * hidden. * @param {number=} opt_secondaryYOffset Optional Y offset for above-block * positioning. * @return {boolean} True if the menu rendered below block; false if above. */ function showPositionedByField(field: Field, opt_onHide?: Function, opt_secondaryYOffset?: number): boolean; /** * Show and place the drop-down. * The drop-down is placed with an absolute "origin point" (x, y) - i.e., * the arrow will point at this origin and box will positioned below or above * it. If we can maintain the container bounds at the primary point, the arrow * will point there, and the container will be positioned below it. * If we can't maintain the container bounds at the primary point, fall-back to * the secondary point and position above. * @param {?Object} owner The object showing the drop-down * @param {boolean} rtl Right-to-left (true) or left-to-right (false). * @param {number} primaryX Desired origin point x, in absolute px. * @param {number} primaryY Desired origin point y, in absolute px. * @param {number} secondaryX Secondary/alternative origin point x, in absolute * px. * @param {number} secondaryY Secondary/alternative origin point y, in absolute * px. * @param {Function=} opt_onHide Optional callback for when the drop-down is * hidden. * @return {boolean} True if the menu rendered at the primary origin point. * @package */ function show(owner: Object, rtl: boolean, primaryX: number, primaryY: number, secondaryX: number, secondaryY: number, opt_onHide?: Function): boolean; /** * Get the x positions for the left side of the DropDownDiv and the arrow, * accounting for the bounds of the workspace. * @param {number} sourceX Desired origin point x, in absolute px. * @param {number} boundsLeft The left edge of the bounding element, in * absolute px. * @param {number} boundsRight The right edge of the bounding element, in * absolute px. * @param {number} divWidth The width of the div in px. * @return {{divX: number, arrowX: number}} An object containing metrics for * the x positions of the left side of the DropDownDiv and the arrow. * @package */ function getPositionX(sourceX: number, boundsLeft: number, boundsRight: number, divWidth: number): { divX: number; arrowX: number }; /** * Is the container visible? * @return {boolean} True if visible. */ function isVisible(): boolean; /** * Hide the menu only if it is owned by the provided object. * @param {?Object} owner Object which must be owning the drop-down to hide. * @param {boolean=} opt_withoutAnimation True if we should hide the dropdown * without animating. * @return {boolean} True if hidden. */ function hideIfOwner(owner: Object, opt_withoutAnimation?: boolean): boolean; /** * Hide the menu, triggering animation. */ function hide(): void; /** * Hide the menu, without animation. */ function hideWithoutAnimation(): void; /** * Repositions the dropdownDiv on window resize. If it doesn't know how to * calculate the new position, it will just hide it instead. * @package */ function repositionForWindowResize(): void; } declare module internal { /** * Get sizing info about the bounding element. * @return {!DropDownDiv.BoundsInfo} An object containing size * information about the bounding element (bounding box and width/height). */ function getBoundsInfo(): DropDownDiv.BoundsInfo; /** * Helper to position the drop-down and the arrow, maintaining bounds. * See explanation of origin points in DropDownDiv.show. * @param {number} primaryX Desired origin point x, in absolute px. * @param {number} primaryY Desired origin point y, in absolute px. * @param {number} secondaryX Secondary/alternative origin point x, * in absolute px. * @param {number} secondaryY Secondary/alternative origin point y, * in absolute px. * @return {!DropDownDiv.PositionMetrics} Various final metrics, * including rendered positions for drop-down and arrow. */ function getPositionMetrics(primaryX: number, primaryY: number, secondaryX: number, secondaryY: number): DropDownDiv.PositionMetrics; } declare module Field { /** * Non-breaking space. * @const */ var NBSP: any /*missing*/; } declare module FieldAngle { /** * Construct a FieldAngle from a JSON arg object. * @param {!Object} options A JSON object with options (angle). * @return {!FieldAngle} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldAngle; /** * The default amount to round angles to when using a mouse or keyboard nav * input. Must be a positive integer to support keyboard navigation. * @const {number} */ var ROUND: any /*missing*/; /** * Half the width of protractor image. * @const {number} */ var HALF: any /*missing*/; /** * Default property describing which direction makes an angle field's value * increase. Angle increases clockwise (true) or counterclockwise (false). * @const {boolean} */ var CLOCKWISE: any /*missing*/; /** * The default offset of 0 degrees (and all angles). Always offsets in the * counterclockwise direction, regardless of the field's clockwise property. * Usually either 0 (0 = right) or 90 (0 = up). * @const {number} */ var OFFSET: any /*missing*/; /** * The default maximum angle to allow before wrapping. * Usually either 360 (for 0 to 359.9) or 180 (for -179.9 to 180). * @const {number} */ var WRAP: any /*missing*/; /** * Radius of protractor circle. Slightly smaller than protractor size since * otherwise SVG crops off half the border at the edges. * @const {number} */ var RADIUS: any /*missing*/; } declare module FieldCheckbox { /** * Construct a FieldCheckbox from a JSON arg object. * @param {!Object} options A JSON object with options (checked). * @return {!FieldCheckbox} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldCheckbox; /** * Default character for the checkmark. * @type {string} * @const */ var CHECK_CHAR: string; } declare module FieldColour { /** * Construct a FieldColour from a JSON arg object. * @param {!Object} options A JSON object with options (colour). * @return {!FieldColour} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldColour; /** * An array of colour strings for the palette. * Copied from goog.ui.ColorPicker.SIMPLE_GRID_COLORS * All colour pickers use this unless overridden with setColours. * @type {!Array} */ var COLOURS: string[]; /** * An array of tooltip strings for the palette. If not the same length as * COLOURS, the colour's hex code will be used for any missing titles. * All colour pickers use this unless overridden with setColours. * @type {!Array} */ var TITLES: string[]; /** * Number of columns in the palette. * All colour pickers use this unless overridden with setColumns. */ var COLUMNS: any /*missing*/; } declare module FieldDropdown { /** * Dropdown image properties. * @typedef {{ * src:string, * alt:string, * width:number, * height:number * }} */ interface ImageProperties { src: string; alt: string; width: number; height: number } /** * Construct a FieldDropdown from a JSON arg object. * @param {!Object} options A JSON object with options (options). * @return {!FieldDropdown} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldDropdown; /** * Horizontal distance that a checkmark overhangs the dropdown. */ var CHECKMARK_OVERHANG: any /*missing*/; /** * Maximum height of the dropdown menu, as a percentage of the viewport height. */ var MAX_MENU_HEIGHT_VH: any /*missing*/; /** * Android can't (in 2014) display "▾", so use "▼" instead. */ var ARROW_CHAR: any /*missing*/; /** * Use the calculated prefix and suffix lengths to trim all of the options in * the given array. * @param {!Array} options Array of option tuples: * (human-readable text or image, language-neutral name). * @param {number} prefixLength The length of the common prefix. * @param {number} suffixLength The length of the common suffix * @return {!Array} A new array with all of the option text trimmed. */ function applyTrim_(options: any[][], prefixLength: number, suffixLength: number): any[][]; } declare module FieldImage { /** * Construct a FieldImage from a JSON arg object, * dereferencing any string table references. * @param {!Object} options A JSON object with options (src, width, height, * alt, and flipRtl). * @return {!FieldImage} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldImage; } declare module FieldLabel { /** * Construct a FieldLabel from a JSON arg object, * dereferencing any string table references. * @param {!Object} options A JSON object with options (text, and class). * @return {!FieldLabel} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldLabel; } declare module FieldLabelSerializable { /** * Construct a FieldLabelSerializable from a JSON arg object, * dereferencing any string table references. * @param {!Object} options A JSON object with options (text, and class). * @return {!FieldLabelSerializable} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldLabelSerializable; } declare module FieldMultilineInput { /** * Construct a FieldMultilineInput from a JSON arg object, * dereferencing any string table references. * @param {!Object} options A JSON object with options (text, and spellcheck). * @return {!FieldMultilineInput} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldMultilineInput; } declare module FieldNumber { /** * Construct a FieldNumber from a JSON arg object. * @param {!Object} options A JSON object with options (value, min, max, and * precision). * @return {!FieldNumber} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldNumber; } declare module FieldTextInput { /** * Construct a FieldTextInput from a JSON arg object, * dereferencing any string table references. * @param {!Object} options A JSON object with options (text, and spellcheck). * @return {!FieldTextInput} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldTextInput; /** * Pixel size of input border radius. * Should match blocklyText's border-radius in CSS. */ var BORDERRADIUS: any /*missing*/; } declare module FieldVariable { /** * Construct a FieldVariable from a JSON arg object, * dereferencing any string table references. * @param {!Object} options A JSON object with options (variable, * variableTypes, and defaultType). * @return {!FieldVariable} The new field instance. * @package * @nocollapse */ function fromJson(options: Object): FieldVariable; /** * Return a sorted list of variable names for variable dropdown menus. * Include a special option at the end for creating a new variable name. * @return {!Array} Array of variable names/id tuples. * @this {FieldVariable} */ function dropdownCreate(): any[][]; } declare module FlyoutButton { /** * The horizontal margin around the text in the button. */ var MARGIN_X: any /*missing*/; /** * The vertical margin around the text in the button. */ var MARGIN_Y: any /*missing*/; } declare module VerticalFlyout { /** * The name of the vertical flyout in the registry. * @type {string} */ var registryName: string; } declare module Gesture { /** * Is a drag or other gesture currently in progress on any workspace? * @return {boolean} True if gesture is occurring. */ function inProgress(): boolean; } declare module Grid { /** * Create the DOM for the grid described by options. * @param {string} rnd A random ID to append to the pattern's ID. * @param {!Object} gridOptions The object containing grid configuration. * @param {!SVGElement} defs The root SVG element for this workspace's defs. * @return {!SVGElement} The SVG element for the grid pattern. * @package */ function createDom(rnd: string, gridOptions: Object, defs: SVGElement): SVGElement; } declare module InsertionMarkerManager { /** * An enum describing different kinds of previews the InsertionMarkerManager * could display. * @enum {number} */ enum PREVIEW_TYPE { INSERTION_MARKER, INPUT_OUTLINE, REPLACEMENT_FADE } /** * An error message to throw if the block created by createMarkerBlock_ is * missing any components. * @type {string} * @const */ var DUPLICATE_BLOCK_ERROR: string; } declare module MarkerManager { /** * The name of the local marker. * @type {string} * @const */ var LOCAL_MARKER: string; } declare module MetricsManager { /** * Describes the width, height and location of the toolbox on the main * workspace. * @typedef {{ * width: number, * height: number, * position: !toolboxUtils.Position * }} */ interface ToolboxMetrics { width: number; height: number; position: toolboxUtils.Position } /** * Describes where the viewport starts in relation to the workspace SVG. * @typedef {{ * left: number, * top: number * }} */ interface AbsoluteMetrics { left: number; top: number } /** * All the measurements needed to describe the size and location of a container. * @typedef {{ * height: number, * width: number, * top: number, * left: number * }} */ interface ContainerRegion { height: number; width: number; top: number; left: number } /** * Describes fixed edges of the workspace. * @typedef {{ * top: (number|undefined), * bottom: (number|undefined), * left: (number|undefined), * right: (number|undefined) * }} */ interface FixedEdges { top: number|any /*undefined*/; bottom: number|any /*undefined*/; left: number|any /*undefined*/; right: number|any /*undefined*/ } /** * Common metrics used for UI elements. * @typedef {{ * viewMetrics: !MetricsManager.ContainerRegion, * absoluteMetrics: !MetricsManager.AbsoluteMetrics, * toolboxMetrics: !MetricsManager.ToolboxMetrics * }} */ interface UiMetrics { viewMetrics: MetricsManager.ContainerRegion; absoluteMetrics: MetricsManager.AbsoluteMetrics; toolboxMetrics: MetricsManager.ToolboxMetrics } } declare module Mutator { /** * Reconnect an block to a mutated input. * @param {Connection} connectionChild Connection on child block. * @param {!Block} block Parent block. * @param {string} inputName Name of input on parent block. * @return {boolean} True iff a reconnection was made, false otherwise. */ function reconnect(connectionChild: Connection, block: Block, inputName: string): boolean; /** * Get the parent workspace of a workspace that is inside a mutator, taking into * account whether it is a flyout. * @param {Workspace} workspace The workspace that is inside a mutator. * @return {?Workspace} The mutator's parent workspace or null. * @public */ function findParentWs(workspace: Workspace): Workspace; } declare module Names { /** * Constant to separate developer variable names from user-defined variable * names when running generators. * A developer variable will be declared as a global in the generated code, but * will never be shown to the user in the workspace or stored in the variable * map. */ var DEVELOPER_VARIABLE_TYPE: any /*missing*/; /** * Do the given two entity names refer to the same entity? * Blockly names are case-insensitive. * @param {string} name1 First name. * @param {string} name2 Second name. * @return {boolean} True if names are the same. */ function equals(name1: string, name2: string): boolean; } declare module Options { /** * Grid Options. * @typedef {{ * colour: string, * length: number, * snap: boolean, * spacing: number * }} */ interface GridOptions { colour: string; length: number; snap: boolean; spacing: number } /** * Move Options. * @typedef {{ * drag: boolean, * scrollbars: (boolean | !Options.ScrollbarOptions), * wheel: boolean * }} */ interface MoveOptions { drag: boolean; scrollbars: boolean|Options.ScrollbarOptions; wheel: boolean } /** * Scrollbar Options. * @typedef {{ * horizontal: boolean, * vertical: boolean * }} */ interface ScrollbarOptions { horizontal: boolean; vertical: boolean } /** * Zoom Options. * @typedef {{ * controls: boolean, * maxScale: number, * minScale: number, * pinch: boolean, * scaleSpeed: number, * startScale: number, * wheel: boolean * }} */ interface ZoomOptions { controls: boolean; maxScale: number; minScale: number; pinch: boolean; scaleSpeed: number; startScale: number; wheel: boolean } } declare module Type { /** @type {!Type} */ var CONNECTION_CHECKER: Type; /** @type {!Type} */ var CURSOR: Type; /** @type {!Type} */ var EVENT: Type; /** @type {!Type} */ var FIELD: Type; /** @type {!Type} */ var RENDERER: Type; /** @type {!Type} */ var TOOLBOX: Type; /** @type {!Type} */ var THEME: Type; /** @type {!Type} */ var TOOLBOX_ITEM: Type; /** @type {!Type} */ var FLYOUTS_VERTICAL_TOOLBOX: Type; /** @type {!Type} */ var FLYOUTS_HORIZONTAL_TOOLBOX: Type; /** @type {!Type} */ var METRICS_MANAGER: Type; /** @type {!Type} */ var BLOCK_DRAGGER: Type; /** * @type {!Type} * @package */ var SERIALIZER: Type; } declare module RenderedConnection { /** * Enum for different kinds of tracked states. * * WILL_TRACK means that this connection will add itself to * the db on the next moveTo call it receives. * * UNTRACKED means that this connection will not add * itself to the database until setTracking(true) is explicitly called. * * TRACKED means that this connection is currently being tracked. * @enum {number} */ enum TrackedState { WILL_TRACK, UNTRACKED, TRACKED } } declare module Scrollbar { /** * Width of vertical scrollbar or height of horizontal scrollbar in CSS pixels. * Scrollbars should be larger on touch devices. */ var scrollbarThickness: any /*missing*/; /** * Default margin around the scrollbar (between the scrollbar and the edge of * the viewport in pixels). * @type {number} * @const * @package */ var DEFAULT_SCROLLBAR_MARGIN: number; } declare module ShortcutRegistry { /** * Enum of valid modifiers. * @enum {!KeyCodes} */ enum modifierKeys { Shift, Control, Alt, Meta } /** * A keyboard shortcut. * @typedef {{ * callback: ((function(!Workspace, Event, * !ShortcutRegistry.KeyboardShortcut):boolean)|undefined), * name: string, * preconditionFn: ((function(!Workspace):boolean)|undefined), * metadata: (Object|undefined) * }} */ interface KeyboardShortcut { callback: { (_0: Workspace, _1: Event, _2: ShortcutRegistry.KeyboardShortcut): boolean }|any /*undefined*/; name: string; preconditionFn: { (_0: Workspace): boolean }|any /*undefined*/; metadata: Object|any /*undefined*/ } } declare module Theme { /** * A block style. * @typedef {{ * colourPrimary:string, * colourSecondary:string, * colourTertiary:string, * hat:string * }} */ interface BlockStyle { colourPrimary: string; colourSecondary: string; colourTertiary: string; hat: string } /** * A category style. * @typedef {{ * colour:string * }} */ interface CategoryStyle { colour: string } /** * A component style. * @typedef {{ * workspaceBackgroundColour:?string, * toolboxBackgroundColour:?string, * toolboxForegroundColour:?string, * flyoutBackgroundColour:?string, * flyoutForegroundColour:?string, * flyoutOpacity:?number, * scrollbarColour:?string, * scrollbarOpacity:?number, * insertionMarkerColour:?string, * insertionMarkerOpacity:?number, * markerColour:?string, * cursorColour:?string, * selectedGlowColour:?string, * selectedGlowOpacity:?number, * replacementGlowColour:?string, * replacementGlowOpacity:?number * }} */ interface ComponentStyle { workspaceBackgroundColour: string; toolboxBackgroundColour: string; toolboxForegroundColour: string; flyoutBackgroundColour: string; flyoutForegroundColour: string; flyoutOpacity: number; scrollbarColour: string; scrollbarOpacity: number; insertionMarkerColour: string; insertionMarkerOpacity: number; markerColour: string; cursorColour: string; selectedGlowColour: string; selectedGlowOpacity: number; replacementGlowColour: string; replacementGlowOpacity: number } /** * A font style. * @typedef {{ * family:?string, * weight:?string, * size:?number * }} */ interface FontStyle { family: string; weight: string; size: number } /** * Define a new Blockly theme. * @param {string} name The name of the theme. * @param {!Object} themeObj An object containing theme properties. * @return {!Theme} A new Blockly theme. */ function defineTheme(name: string, themeObj: Object): Theme; } declare module ThemeManager { /** * A Blockly UI component type. * @typedef {{ * element:!Element, * propertyName:string * }} */ interface Component { element: Element; propertyName: string } } declare module TouchGesture { /** * A multiplier used to convert the gesture scale to a zoom in delta. * @const */ var ZOOM_IN_MULTIPLIER: any /*missing*/; /** * A multiplier used to convert the gesture scale to a zoom out delta. * @const */ var ZOOM_OUT_MULTIPLIER: any /*missing*/; } declare module VariableModel { /** * A custom compare function for the VariableModel objects. * @param {VariableModel} var1 First variable to compare. * @param {VariableModel} var2 Second variable to compare. * @return {number} -1 if name of var1 is less than name of var2, 0 if equal, * and 1 if greater. * @package */ function compareByName(var1: VariableModel, var2: VariableModel): number; } declare module Workspace { /** * Angle away from the horizontal to sweep for blocks. Order of execution is * generally top to bottom, but a small angle changes the scan to give a bit of * a left to right bias (reversed in RTL). Units are in degrees. * See: https://tvtropes.org/pmwiki/pmwiki.php/Main/DiagonalBilling */ var SCAN_ANGLE: any /*missing*/; /** * Find the workspace with the specified ID. * @param {string} id ID of workspace to find. * @return {?Workspace} The sought after workspace or null if not found. */ function getById(id: string): Workspace; /** * Find all workspaces. * @return {!Array} Array of workspaces. */ function getAll(): Workspace[]; } declare module WorkspaceComment { /** * Fire a create event for the given workspace comment, if comments are enabled. * @param {!WorkspaceComment} comment The comment that was just created. * @package */ function fireCreateEvent(comment: WorkspaceComment): void; /** * Decode an XML comment tag and create a comment on the workspace. * @param {!Element} xmlComment XML comment element. * @param {!Workspace} workspace The workspace. * @return {!WorkspaceComment} The created workspace comment. * @package */ function fromXml(xmlComment: Element, workspace: Workspace): WorkspaceComment; /** * Decode an XML comment tag and return the results in an object. * @param {!Element} xml XML comment element. * @return {{w: number, h: number, x: number, y: number, content: string}} An * object containing the id, size, position, and comment string. * @package */ function parseAttributes(xml: Element): { w: number; h: number; x: number; y: number; content: string }; } declare module WorkspaceCommentSvg { /** * The width and height to use to size a workspace comment when it is first * added, before it has been edited by the user. * @type {number} * @package */ var DEFAULT_SIZE: number; /** * Decode an XML comment tag and create a rendered comment on the workspace. * @param {!Element} xmlComment XML comment element. * @param {!WorkspaceSvg} workspace The workspace. * @param {number=} opt_wsWidth The width of the workspace, which is used to * position comments correctly in RTL. * @return {!WorkspaceCommentSvg} The created workspace comment. * @package */ function fromXml(xmlComment: Element, workspace: WorkspaceSvg, opt_wsWidth?: number): WorkspaceCommentSvg; } declare module BlockChange { /** * Returns the extra state of the given block (either as XML or a JSO, depending * on the block's definition). * @param {!BlockSvg} block The block to get the extra state of. * @return {string} A stringified version of the extra state of the given block. * @package */ function getExtraBlockState_(block: BlockSvg): string; } declare module CommentBase { /** * Helper function for Comment[Create|Delete] * @param {!CommentCreate|!CommentDelete} event * The event to run. * @param {boolean} create if True then Create, if False then Delete */ function CommentCreateDeleteHelper(event: CommentCreate|CommentDelete, create: boolean): void; } declare module IComponent { /** * The unique id for this component that is used to register with the * ComponentManager. * @type {string} */ var id: string; } declare module ICopyable { /** * Copy Metadata. * @typedef {{ * saveInfo:(!Object|!Element), * source:WorkspaceSvg, * typeCounts:?Object * }} */ interface CopyData { saveInfo: Object|Element; source: WorkspaceSvg; typeCounts: Object } } declare module IRegistrableField { /** * @typedef {function(!Object): Field} */ interface fromJson { (_0: Object): Field } } declare module ASTNode { /** * @typedef {{ * wsCoordinate: Coordinate * }} */ interface Params { wsCoordinate: Coordinate } /** * Object holding different types for an AST node. * @enum {string} */ enum types { FIELD, BLOCK, INPUT, OUTPUT, NEXT, PREVIOUS, STACK, WORKSPACE } /** * True to navigate to all fields. False to only navigate to clickable fields. * @type {boolean} */ var NAVIGATE_ALL_FIELDS: boolean; /** * Create an AST node pointing to a field. * @param {Field} field The location of the AST node. * @return {ASTNode} An AST node pointing to a field. */ function createFieldNode(field: Field): ASTNode; /** * Creates an AST node pointing to a connection. If the connection has a parent * input then create an AST node of type input that will hold the connection. * @param {Connection} connection This is the connection the node will * point to. * @return {ASTNode} An AST node pointing to a connection. */ function createConnectionNode(connection: Connection): ASTNode; /** * Creates an AST node pointing to an input. Stores the input connection as the * location. * @param {Input} input The input used to create an AST node. * @return {ASTNode} An AST node pointing to a input. */ function createInputNode(input: Input): ASTNode; /** * Creates an AST node pointing to a block. * @param {Block} block The block used to create an AST node. * @return {ASTNode} An AST node pointing to a block. */ function createBlockNode(block: Block): ASTNode; /** * Create an AST node of type stack. A stack, represented by its top block, is * the set of all blocks connected to a top block, including the top block. * @param {Block} topBlock A top block has no parent and can be found * in the list returned by workspace.getTopBlocks(). * @return {ASTNode} An AST node of type stack that points to the top * block on the stack. */ function createStackNode(topBlock: Block): ASTNode; /** * Creates an AST node pointing to a workspace. * @param {!Workspace} workspace The workspace that we are on. * @param {Coordinate} wsCoordinate The position on the workspace * for this node. * @return {ASTNode} An AST node pointing to a workspace and a position * on the workspace. */ function createWorkspaceNode(workspace: Workspace, wsCoordinate: Coordinate): ASTNode; /** * Creates an AST node for the top position on a block. * This is either an output connection, previous connection, or block. * @param {!Block} block The block to find the top most AST node on. * @return {ASTNode} The AST node holding the top most position on the * block. */ function createTopNode(block: Block): ASTNode; } declare module BasicCursor { /** * Name used for registering a basic cursor. * @const {string} */ var registrationName: any /*missing*/; } declare module exports { /** * The priority for deserializing variables. * @type {number} * @const * @alias Blockly.serialization.priorities.VARIABLES */ var VARIABLES: number; /** * The priority for deserializing blocks. * @type {number} * @const * @alias Blockly.serialization.priorities.BLOCKS */ var BLOCKS: number; } declare module ToolboxCategory { /** * All the CSS class names that are used to create a category. * @typedef {{ * container:(string|undefined), * row:(string|undefined), * rowcontentcontainer:(string|undefined), * icon:(string|undefined), * label:(string|undefined), * selected:(string|undefined), * openicon:(string|undefined), * closedicon:(string|undefined) * }} */ interface CssConfig { container: string|any /*undefined*/; row: string|any /*undefined*/; rowcontentcontainer: string|any /*undefined*/; icon: string|any /*undefined*/; label: string|any /*undefined*/; selected: string|any /*undefined*/; openicon: string|any /*undefined*/; closedicon: string|any /*undefined*/ } /** * Name used for registering a toolbox category. * @const {string} */ var registrationName: any /*missing*/; /** * The number of pixels to move the category over at each nested level. * @type {number} */ var nestedPadding: number; /** * The width in pixels of the strip of colour next to each category. * @type {number} */ var borderWidth: number; /** * The default colour of the category. This is used as the background colour of * the category when it is selected. * @type {string} */ var defaultBackgroundColour: string; } declare module CollapsibleToolboxCategory { /** * All the CSS class names that are used to create a collapsible * category. This is all the properties from the regular category plus contents. * @typedef {{ * container:?string, * row:?string, * rowcontentcontainer:?string, * icon:?string, * label:?string, * selected:?string, * openicon:?string, * closedicon:?string, * contents:?string * }} */ interface CssConfig { container: string; row: string; rowcontentcontainer: string; icon: string; label: string; selected: string; openicon: string; closedicon: string; contents: string } /** * Name used for registering a collapsible toolbox category. * @const {string} */ var registrationName: any /*missing*/; } declare module ToolboxSeparator { /** * All the CSS class names that are used to create a separator. * @typedef {{ * container:(string|undefined) * }} */ interface CssConfig { container: string|any /*undefined*/ } /** * Name used for registering a toolbox separator. * @const {string} */ var registrationName: any /*missing*/; } declare module Coordinate { /** * Compares coordinates for equality. * @param {?Coordinate} a A Coordinate. * @param {?Coordinate} b A Coordinate. * @return {boolean} True iff the coordinates are equal, or if both are null. */ function equals(a: Coordinate, b: Coordinate): boolean; /** * Returns the distance between two coordinates. * @param {!Coordinate} a A Coordinate. * @param {!Coordinate} b A Coordinate. * @return {number} The distance between `a` and `b`. */ function distance(a: Coordinate, b: Coordinate): number; /** * Returns the magnitude of a coordinate. * @param {!Coordinate} a A Coordinate. * @return {number} The distance between the origin and `a`. */ function magnitude(a: Coordinate): number; /** * Returns the difference between two coordinates as a new * Coordinate. * @param {!Coordinate|!SVGPoint} a An x/y coordinate. * @param {!Coordinate|!SVGPoint} b An x/y coordinate. * @return {!Coordinate} A Coordinate representing the difference * between `a` and `b`. */ function difference(a: Coordinate|SVGPoint, b: Coordinate|SVGPoint): Coordinate; /** * Returns the sum of two coordinates as a new Coordinate. * @param {!Coordinate|!SVGPoint} a An x/y coordinate. * @param {!Coordinate|!SVGPoint} b An x/y coordinate. * @return {!Coordinate} A Coordinate representing the sum of * the two coordinates. */ function sum(a: Coordinate|SVGPoint, b: Coordinate|SVGPoint): Coordinate; } declare module exports { /** * Reference to the global object. * * More info on this implementation here: * https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI */ var globalThis: any /*missing*/; } declare module internal { /** * Generate a random unique ID. This should be globally unique. * 87 characters ^ 20 length > 128 bits (better than a UUID). * @return {string} A globally unique ID string. */ function genUid(): string; } declare module Size { /** * Compares sizes for equality. * @param {?Size} a A Size. * @param {?Size} b A Size. * @return {boolean} True iff the sizes have equal widths and equal * heights, or if both are null. */ function equals(a: Size, b: Size): boolean; } declare module Svg { /** * @type {!Svg} * @package */ var ANIMATE: Svg; /** * @type {!Svg} * @package */ var CIRCLE: Svg; /** * @type {!Svg} * @package */ var CLIPPATH: Svg; /** * @type {!Svg} * @package */ var DEFS: Svg; /** * @type {!Svg} * @package */ var FECOMPOSITE: Svg; /** * @type {!Svg} * @package */ var FECOMPONENTTRANSFER: Svg; /** * @type {!Svg} * @package */ var FEFLOOD: Svg; /** * @type {!Svg} * @package */ var FEFUNCA: Svg; /** * @type {!Svg} * @package */ var FEGAUSSIANBLUR: Svg; /** * @type {!Svg} * @package */ var FEPOINTLIGHT: Svg; /** * @type {!Svg} * @package */ var FESPECULARLIGHTING: Svg; /** * @type {!Svg} * @package */ var FILTER: Svg; /** * @type {!Svg} * @package */ var FOREIGNOBJECT: Svg; /** * @type {!Svg} * @package */ var G: Svg; /** * @type {!Svg} * @package */ var IMAGE: Svg; /** * @type {!Svg} * @package */ var LINE: Svg; /** * @type {!Svg} * @package */ var PATH: Svg; /** * @type {!Svg} * @package */ var PATTERN: Svg; /** * @type {!Svg} * @package */ var POLYGON: Svg; /** * @type {!Svg} * @package */ var RECT: Svg; /** * @type {!Svg} * @package */ var SVG: Svg; /** * @type {!Svg} * @package */ var TEXT: Svg; /** * @type {!Svg} * @package */ var TSPAN: Svg; } declare module exports { /** @const {string} * @alias Blockly.utils.userAgent.raw */ var raw: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.IE */ var IE: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.EDGE */ var EDGE: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.JavaFx */ var JavaFx: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.CHROME */ var CHROME: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.WEBKIT */ var WEBKIT: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.GECKO */ var GECKO: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.ANDROID */ var ANDROID: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.IPAD */ var IPAD: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.IPOD */ var IPOD: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.IPHONE */ var IPHONE: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.MAC */ var MAC: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.TABLET */ var TABLET: any /*missing*/; /** @const {boolean} * @alias Blockly.utils.userAgent.MOBILE */ var MOBILE: any /*missing*/; } declare module Debug { /** * Configuration object containing booleans to enable and disable debug * rendering of specific rendering components. * @type {!Object} */ var config: { [key: string]: boolean }; } declare module Types { /** * A Left Corner Union Type. * @type {number} * @const * @package */ var LEFT_CORNER: number; /** * A Right Corner Union Type. * @type {number} * @const * @package */ var RIGHT_CORNER: number; /** * Get the enum flag value of an existing type or register a new type. * @param {!string} type The name of the type. * @return {!number} The enum flag value associated with that type. * @package */ function getType(type: string): number; /** * Whether a measurable stores information about a field. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a field. * @package */ function isField(elem: Measurable): number; /** * Whether a measurable stores information about a hat. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a hat. * @package */ function isHat(elem: Measurable): number; /** * Whether a measurable stores information about an icon. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about an icon. * @package */ function isIcon(elem: Measurable): number; /** * Whether a measurable stores information about a spacer. * @param {!Measurable|!Row} elem * The element to check. * @return {number} 1 if the object stores information about a spacer. * @package */ function isSpacer(elem: Measurable|Row): number; /** * Whether a measurable stores information about an in-row spacer. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about an * in-row spacer. * @package */ function isInRowSpacer(elem: Measurable): number; /** * Whether a measurable stores information about an input. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about an input. * @package */ function isInput(elem: Measurable): number; /** * Whether a measurable stores information about an external input. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about an * external input. * @package */ function isExternalInput(elem: Measurable): number; /** * Whether a measurable stores information about an inline input. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about an * inline input. * @package */ function isInlineInput(elem: Measurable): number; /** * Whether a measurable stores information about a statement input. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a * statement input. * @package */ function isStatementInput(elem: Measurable): number; /** * Whether a measurable stores information about a previous connection. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a * previous connection. * @package */ function isPreviousConnection(elem: Measurable): number; /** * Whether a measurable stores information about a next connection. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a * next connection. * @package */ function isNextConnection(elem: Measurable): number; /** * Whether a measurable stores information about a previous or next connection. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a previous or * next connection. * @package */ function isPreviousOrNextConnection(elem: Measurable): number; /** * Whether a measurable stores information about a left round corner. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a * left round corner. * @package */ function isLeftRoundedCorner(elem: Measurable): number; /** * Whether a measurable stores information about a right round corner. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a * right round corner. * @package */ function isRightRoundedCorner(elem: Measurable): number; /** * Whether a measurable stores information about a left square corner. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a * left square corner. * @package */ function isLeftSquareCorner(elem: Measurable): number; /** * Whether a measurable stores information about a right square corner. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a * right square corner. * @package */ function isRightSquareCorner(elem: Measurable): number; /** * Whether a measurable stores information about a corner. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a * corner. * @package */ function isCorner(elem: Measurable): number; /** * Whether a measurable stores information about a jagged edge. * @param {!Measurable} elem The element to check. * @return {number} 1 if the object stores information about a jagged edge. * @package */ function isJaggedEdge(elem: Measurable): number; /** * Whether a measurable stores information about a row. * @param {!Row} row The row to check. * @return {number} 1 if the object stores information about a row. * @package */ function isRow(row: Row): number; /** * Whether a measurable stores information about a between-row spacer. * @param {!Row} row The row to check. * @return {number} 1 if the object stores information about a * between-row spacer. * @package */ function isBetweenRowSpacer(row: Row): number; /** * Whether a measurable stores information about a top row. * @param {!Row} row The row to check. * @return {number} 1 if the object stores information about a top row. * @package */ function isTopRow(row: Row): number; /** * Whether a measurable stores information about a bottom row. * @param {!Row} row The row to check. * @return {number} 1 if the object stores information about a bottom row. * @package */ function isBottomRow(row: Row): number; /** * Whether a measurable stores information about a top or bottom row. * @param {!Row} row The row to check. * @return {number} 1 if the object stores information about a top or * bottom row. * @package */ function isTopOrBottomRow(row: Row): number; /** * Whether a measurable stores information about an input row. * @param {!Row} row The row to check. * @return {number} 1 if the object stores information about an input row. * @package */ function isInputRow(row: Row): number; } declare module Blockly.Msg { /** @type {string} */ var LOGIC_HUE: string; /** @type {string} */ var LOOPS_HUE: string; /** @type {string} */ var MATH_HUE: string; /** @type {string} */ var TEXTS_HUE: string; /** @type {string} */ var LISTS_HUE: string; /** @type {string} */ var COLOUR_HUE: string; /** @type {string} */ var VARIABLES_HUE: string; /** @type {string} */ var VARIABLES_DYNAMIC_HUE: string; /** @type {string} */ var PROCEDURES_HUE: string; /** @type {string} */ var VARIABLES_DEFAULT_NAME: string; /** @type {string} */ var UNNAMED_KEY: string; /** @type {string} */ var TODAY: string; /** @type {string} */ var DUPLICATE_BLOCK: string; /** @type {string} */ var ADD_COMMENT: string; /** @type {string} */ var REMOVE_COMMENT: string; /** @type {string} */ var DUPLICATE_COMMENT: string; /** @type {string} */ var EXTERNAL_INPUTS: string; /** @type {string} */ var INLINE_INPUTS: string; /** @type {string} */ var DELETE_BLOCK: string; /** @type {string} */ var DELETE_X_BLOCKS: string; /** @type {string} */ var DELETE_ALL_BLOCKS: string; /** @type {string} */ var CLEAN_UP: string; /** @type {string} */ var COLLAPSE_BLOCK: string; /** @type {string} */ var COLLAPSE_ALL: string; /** @type {string} */ var EXPAND_BLOCK: string; /** @type {string} */ var EXPAND_ALL: string; /** @type {string} */ var DISABLE_BLOCK: string; /** @type {string} */ var ENABLE_BLOCK: string; /** @type {string} */ var HELP: string; /** @type {string} */ var UNDO: string; /** @type {string} */ var REDO: string; /** @type {string} */ var CHANGE_VALUE_TITLE: string; /** @type {string} */ var RENAME_VARIABLE: string; /** @type {string} */ var RENAME_VARIABLE_TITLE: string; /** @type {string} */ var NEW_VARIABLE: string; /** @type {string} */ var NEW_STRING_VARIABLE: string; /** @type {string} */ var NEW_NUMBER_VARIABLE: string; /** @type {string} */ var NEW_COLOUR_VARIABLE: string; /** @type {string} */ var NEW_VARIABLE_TYPE_TITLE: string; /** @type {string} */ var NEW_VARIABLE_TITLE: string; /** @type {string} */ var VARIABLE_ALREADY_EXISTS: string; /** @type {string} */ var VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE: string; /** @type {string} */ var DELETE_VARIABLE_CONFIRMATION: string; /** @type {string} */ var CANNOT_DELETE_VARIABLE_PROCEDURE: string; /** @type {string} */ var DELETE_VARIABLE: string; /** @type {string} */ var COLOUR_PICKER_HELPURL: string; /** @type {string} */ var COLOUR_PICKER_TOOLTIP: string; /** @type {string} */ var COLOUR_RANDOM_HELPURL: string; /** @type {string} */ var COLOUR_RANDOM_TITLE: string; /** @type {string} */ var COLOUR_RANDOM_TOOLTIP: string; /** @type {string} */ var COLOUR_RGB_HELPURL: string; /** @type {string} */ var COLOUR_RGB_TITLE: string; /** @type {string} */ var COLOUR_RGB_RED: string; /** @type {string} */ var COLOUR_RGB_GREEN: string; /** @type {string} */ var COLOUR_RGB_BLUE: string; /** @type {string} */ var COLOUR_RGB_TOOLTIP: string; /** @type {string} */ var COLOUR_BLEND_HELPURL: string; /** @type {string} */ var COLOUR_BLEND_TITLE: string; /** @type {string} */ var COLOUR_BLEND_COLOUR1: string; /** @type {string} */ var COLOUR_BLEND_COLOUR2: string; /** @type {string} */ var COLOUR_BLEND_RATIO: string; /** @type {string} */ var COLOUR_BLEND_TOOLTIP: string; /** @type {string} */ var CONTROLS_REPEAT_HELPURL: string; /** @type {string} */ var CONTROLS_REPEAT_TITLE: string; /** @type {string} */ var CONTROLS_REPEAT_INPUT_DO: string; /** @type {string} */ var CONTROLS_REPEAT_TOOLTIP: string; /** @type {string} */ var CONTROLS_WHILEUNTIL_HELPURL: string; /** @type {string} */ var CONTROLS_WHILEUNTIL_INPUT_DO: string; /** @type {string} */ var CONTROLS_WHILEUNTIL_OPERATOR_WHILE: string; /** @type {string} */ var CONTROLS_WHILEUNTIL_OPERATOR_UNTIL: string; /** @type {string} */ var CONTROLS_WHILEUNTIL_TOOLTIP_WHILE: string; /** @type {string} */ var CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL: string; /** @type {string} */ var CONTROLS_FOR_HELPURL: string; /** @type {string} */ var CONTROLS_FOR_TOOLTIP: string; /** @type {string} */ var CONTROLS_FOR_TITLE: string; /** @type {string} */ var CONTROLS_FOR_INPUT_DO: string; /** @type {string} */ var CONTROLS_FOREACH_HELPURL: string; /** @type {string} */ var CONTROLS_FOREACH_TITLE: string; /** @type {string} */ var CONTROLS_FOREACH_INPUT_DO: string; /** @type {string} */ var CONTROLS_FOREACH_TOOLTIP: string; /** @type {string} */ var CONTROLS_FLOW_STATEMENTS_HELPURL: string; /** @type {string} */ var CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK: string; /** @type {string} */ var CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE: string; /** @type {string} */ var CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK: string; /** @type {string} */ var CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE: string; /** @type {string} */ var CONTROLS_FLOW_STATEMENTS_WARNING: string; /** @type {string} */ var CONTROLS_IF_HELPURL: string; /** @type {string} */ var CONTROLS_IF_TOOLTIP_1: string; /** @type {string} */ var CONTROLS_IF_TOOLTIP_2: string; /** @type {string} */ var CONTROLS_IF_TOOLTIP_3: string; /** @type {string} */ var CONTROLS_IF_TOOLTIP_4: string; /** @type {string} */ var CONTROLS_IF_MSG_IF: string; /** @type {string} */ var CONTROLS_IF_MSG_ELSEIF: string; /** @type {string} */ var CONTROLS_IF_MSG_ELSE: string; /** @type {string} */ var CONTROLS_IF_MSG_THEN: string; /** @type {string} */ var CONTROLS_IF_IF_TITLE_IF: string; /** @type {string} */ var CONTROLS_IF_IF_TOOLTIP: string; /** @type {string} */ var CONTROLS_IF_ELSEIF_TITLE_ELSEIF: string; /** @type {string} */ var CONTROLS_IF_ELSEIF_TOOLTIP: string; /** @type {string} */ var CONTROLS_IF_ELSE_TITLE_ELSE: string; /** @type {string} */ var CONTROLS_IF_ELSE_TOOLTIP: string; /** @type {string} */ var LOGIC_COMPARE_HELPURL: string; /** @type {string} */ var LOGIC_COMPARE_TOOLTIP_EQ: string; /** @type {string} */ var LOGIC_COMPARE_TOOLTIP_NEQ: string; /** @type {string} */ var LOGIC_COMPARE_TOOLTIP_LT: string; /** @type {string} */ var LOGIC_COMPARE_TOOLTIP_LTE: string; /** @type {string} */ var LOGIC_COMPARE_TOOLTIP_GT: string; /** @type {string} */ var LOGIC_COMPARE_TOOLTIP_GTE: string; /** @type {string} */ var LOGIC_OPERATION_HELPURL: string; /** @type {string} */ var LOGIC_OPERATION_TOOLTIP_AND: string; /** @type {string} */ var LOGIC_OPERATION_AND: string; /** @type {string} */ var LOGIC_OPERATION_TOOLTIP_OR: string; /** @type {string} */ var LOGIC_OPERATION_OR: string; /** @type {string} */ var LOGIC_NEGATE_HELPURL: string; /** @type {string} */ var LOGIC_NEGATE_TITLE: string; /** @type {string} */ var LOGIC_NEGATE_TOOLTIP: string; /** @type {string} */ var LOGIC_BOOLEAN_HELPURL: string; /** @type {string} */ var LOGIC_BOOLEAN_TRUE: string; /** @type {string} */ var LOGIC_BOOLEAN_FALSE: string; /** @type {string} */ var LOGIC_BOOLEAN_TOOLTIP: string; /** @type {string} */ var LOGIC_NULL_HELPURL: string; /** @type {string} */ var LOGIC_NULL: string; /** @type {string} */ var LOGIC_NULL_TOOLTIP: string; /** @type {string} */ var LOGIC_TERNARY_HELPURL: string; /** @type {string} */ var LOGIC_TERNARY_CONDITION: string; /** @type {string} */ var LOGIC_TERNARY_IF_TRUE: string; /** @type {string} */ var LOGIC_TERNARY_IF_FALSE: string; /** @type {string} */ var LOGIC_TERNARY_TOOLTIP: string; /** @type {string} */ var MATH_NUMBER_HELPURL: string; /** @type {string} */ var MATH_NUMBER_TOOLTIP: string; /** @type {string} */ var MATH_ADDITION_SYMBOL: string; /** @type {string} */ var MATH_SUBTRACTION_SYMBOL: string; /** @type {string} */ var MATH_DIVISION_SYMBOL: string; /** @type {string} */ var MATH_MULTIPLICATION_SYMBOL: string; /** @type {string} */ var MATH_POWER_SYMBOL: string; /** @type {string} */ var MATH_TRIG_SIN: string; /** @type {string} */ var MATH_TRIG_COS: string; /** @type {string} */ var MATH_TRIG_TAN: string; /** @type {string} */ var MATH_TRIG_ASIN: string; /** @type {string} */ var MATH_TRIG_ACOS: string; /** @type {string} */ var MATH_TRIG_ATAN: string; /** @type {string} */ var MATH_ARITHMETIC_HELPURL: string; /** @type {string} */ var MATH_ARITHMETIC_TOOLTIP_ADD: string; /** @type {string} */ var MATH_ARITHMETIC_TOOLTIP_MINUS: string; /** @type {string} */ var MATH_ARITHMETIC_TOOLTIP_MULTIPLY: string; /** @type {string} */ var MATH_ARITHMETIC_TOOLTIP_DIVIDE: string; /** @type {string} */ var MATH_ARITHMETIC_TOOLTIP_POWER: string; /** @type {string} */ var MATH_SINGLE_HELPURL: string; /** @type {string} */ var MATH_SINGLE_OP_ROOT: string; /** @type {string} */ var MATH_SINGLE_TOOLTIP_ROOT: string; /** @type {string} */ var MATH_SINGLE_OP_ABSOLUTE: string; /** @type {string} */ var MATH_SINGLE_TOOLTIP_ABS: string; /** @type {string} */ var MATH_SINGLE_TOOLTIP_NEG: string; /** @type {string} */ var MATH_SINGLE_TOOLTIP_LN: string; /** @type {string} */ var MATH_SINGLE_TOOLTIP_LOG10: string; /** @type {string} */ var MATH_SINGLE_TOOLTIP_EXP: string; /** @type {string} */ var MATH_SINGLE_TOOLTIP_POW10: string; /** @type {string} */ var MATH_TRIG_HELPURL: string; /** @type {string} */ var MATH_TRIG_TOOLTIP_SIN: string; /** @type {string} */ var MATH_TRIG_TOOLTIP_COS: string; /** @type {string} */ var MATH_TRIG_TOOLTIP_TAN: string; /** @type {string} */ var MATH_TRIG_TOOLTIP_ASIN: string; /** @type {string} */ var MATH_TRIG_TOOLTIP_ACOS: string; /** @type {string} */ var MATH_TRIG_TOOLTIP_ATAN: string; /** @type {string} */ var MATH_CONSTANT_HELPURL: string; /** @type {string} */ var MATH_CONSTANT_TOOLTIP: string; /** @type {string} */ var MATH_IS_EVEN: string; /** @type {string} */ var MATH_IS_ODD: string; /** @type {string} */ var MATH_IS_PRIME: string; /** @type {string} */ var MATH_IS_WHOLE: string; /** @type {string} */ var MATH_IS_POSITIVE: string; /** @type {string} */ var MATH_IS_NEGATIVE: string; /** @type {string} */ var MATH_IS_DIVISIBLE_BY: string; /** @type {string} */ var MATH_IS_TOOLTIP: string; /** @type {string} */ var MATH_CHANGE_HELPURL: string; /** @type {string} */ var MATH_CHANGE_TITLE: string; /** @type {string} */ var MATH_CHANGE_TITLE_ITEM: string; /** @type {string} */ var MATH_CHANGE_TOOLTIP: string; /** @type {string} */ var MATH_ROUND_HELPURL: string; /** @type {string} */ var MATH_ROUND_TOOLTIP: string; /** @type {string} */ var MATH_ROUND_OPERATOR_ROUND: string; /** @type {string} */ var MATH_ROUND_OPERATOR_ROUNDUP: string; /** @type {string} */ var MATH_ROUND_OPERATOR_ROUNDDOWN: string; /** @type {string} */ var MATH_ONLIST_HELPURL: string; /** @type {string} */ var MATH_ONLIST_OPERATOR_SUM: string; /** @type {string} */ var MATH_ONLIST_TOOLTIP_SUM: string; /** @type {string} */ var MATH_ONLIST_OPERATOR_MIN: string; /** @type {string} */ var MATH_ONLIST_TOOLTIP_MIN: string; /** @type {string} */ var MATH_ONLIST_OPERATOR_MAX: string; /** @type {string} */ var MATH_ONLIST_TOOLTIP_MAX: string; /** @type {string} */ var MATH_ONLIST_OPERATOR_AVERAGE: string; /** @type {string} */ var MATH_ONLIST_TOOLTIP_AVERAGE: string; /** @type {string} */ var MATH_ONLIST_OPERATOR_MEDIAN: string; /** @type {string} */ var MATH_ONLIST_TOOLTIP_MEDIAN: string; /** @type {string} */ var MATH_ONLIST_OPERATOR_MODE: string; /** @type {string} */ var MATH_ONLIST_TOOLTIP_MODE: string; /** @type {string} */ var MATH_ONLIST_OPERATOR_STD_DEV: string; /** @type {string} */ var MATH_ONLIST_TOOLTIP_STD_DEV: string; /** @type {string} */ var MATH_ONLIST_OPERATOR_RANDOM: string; /** @type {string} */ var MATH_ONLIST_TOOLTIP_RANDOM: string; /** @type {string} */ var MATH_MODULO_HELPURL: string; /** @type {string} */ var MATH_MODULO_TITLE: string; /** @type {string} */ var MATH_MODULO_TOOLTIP: string; /** @type {string} */ var MATH_CONSTRAIN_HELPURL: string; /** @type {string} */ var MATH_CONSTRAIN_TITLE: string; /** @type {string} */ var MATH_CONSTRAIN_TOOLTIP: string; /** @type {string} */ var MATH_RANDOM_INT_HELPURL: string; /** @type {string} */ var MATH_RANDOM_INT_TITLE: string; /** @type {string} */ var MATH_RANDOM_INT_TOOLTIP: string; /** @type {string} */ var MATH_RANDOM_FLOAT_HELPURL: string; /** @type {string} */ var MATH_RANDOM_FLOAT_TITLE_RANDOM: string; /** @type {string} */ var MATH_RANDOM_FLOAT_TOOLTIP: string; /** @type {string} */ var MATH_ATAN2_HELPURL: string; /** @type {string} */ var MATH_ATAN2_TITLE: string; /** @type {string} */ var MATH_ATAN2_TOOLTIP: string; /** @type {string} */ var TEXT_TEXT_HELPURL: string; /** @type {string} */ var TEXT_TEXT_TOOLTIP: string; /** @type {string} */ var TEXT_JOIN_HELPURL: string; /** @type {string} */ var TEXT_JOIN_TITLE_CREATEWITH: string; /** @type {string} */ var TEXT_JOIN_TOOLTIP: string; /** @type {string} */ var TEXT_CREATE_JOIN_TITLE_JOIN: string; /** @type {string} */ var TEXT_CREATE_JOIN_TOOLTIP: string; /** @type {string} */ var TEXT_CREATE_JOIN_ITEM_TITLE_ITEM: string; /** @type {string} */ var TEXT_CREATE_JOIN_ITEM_TOOLTIP: string; /** @type {string} */ var TEXT_APPEND_HELPURL: string; /** @type {string} */ var TEXT_APPEND_TITLE: string; /** @type {string} */ var TEXT_APPEND_VARIABLE: string; /** @type {string} */ var TEXT_APPEND_TOOLTIP: string; /** @type {string} */ var TEXT_LENGTH_HELPURL: string; /** @type {string} */ var TEXT_LENGTH_TITLE: string; /** @type {string} */ var TEXT_LENGTH_TOOLTIP: string; /** @type {string} */ var TEXT_ISEMPTY_HELPURL: string; /** @type {string} */ var TEXT_ISEMPTY_TITLE: string; /** @type {string} */ var TEXT_ISEMPTY_TOOLTIP: string; /** @type {string} */ var TEXT_INDEXOF_HELPURL: string; /** @type {string} */ var TEXT_INDEXOF_TOOLTIP: string; /** @type {string} */ var TEXT_INDEXOF_TITLE: string; /** @type {string} */ var TEXT_INDEXOF_OPERATOR_FIRST: string; /** @type {string} */ var TEXT_INDEXOF_OPERATOR_LAST: string; /** @type {string} */ var TEXT_CHARAT_HELPURL: string; /** @type {string} */ var TEXT_CHARAT_TITLE: string; /** @type {string} */ var TEXT_CHARAT_FROM_START: string; /** @type {string} */ var TEXT_CHARAT_FROM_END: string; /** @type {string} */ var TEXT_CHARAT_FIRST: string; /** @type {string} */ var TEXT_CHARAT_LAST: string; /** @type {string} */ var TEXT_CHARAT_RANDOM: string; /** @type {string} */ var TEXT_CHARAT_TAIL: string; /** @type {string} */ var TEXT_CHARAT_TOOLTIP: string; /** @type {string} */ var TEXT_GET_SUBSTRING_TOOLTIP: string; /** @type {string} */ var TEXT_GET_SUBSTRING_HELPURL: string; /** @type {string} */ var TEXT_GET_SUBSTRING_INPUT_IN_TEXT: string; /** @type {string} */ var TEXT_GET_SUBSTRING_START_FROM_START: string; /** @type {string} */ var TEXT_GET_SUBSTRING_START_FROM_END: string; /** @type {string} */ var TEXT_GET_SUBSTRING_START_FIRST: string; /** @type {string} */ var TEXT_GET_SUBSTRING_END_FROM_START: string; /** @type {string} */ var TEXT_GET_SUBSTRING_END_FROM_END: string; /** @type {string} */ var TEXT_GET_SUBSTRING_END_LAST: string; /** @type {string} */ var TEXT_GET_SUBSTRING_TAIL: string; /** @type {string} */ var TEXT_CHANGECASE_HELPURL: string; /** @type {string} */ var TEXT_CHANGECASE_TOOLTIP: string; /** @type {string} */ var TEXT_CHANGECASE_OPERATOR_UPPERCASE: string; /** @type {string} */ var TEXT_CHANGECASE_OPERATOR_LOWERCASE: string; /** @type {string} */ var TEXT_CHANGECASE_OPERATOR_TITLECASE: string; /** @type {string} */ var TEXT_TRIM_HELPURL: string; /** @type {string} */ var TEXT_TRIM_TOOLTIP: string; /** @type {string} */ var TEXT_TRIM_OPERATOR_BOTH: string; /** @type {string} */ var TEXT_TRIM_OPERATOR_LEFT: string; /** @type {string} */ var TEXT_TRIM_OPERATOR_RIGHT: string; /** @type {string} */ var TEXT_PRINT_HELPURL: string; /** @type {string} */ var TEXT_PRINT_TITLE: string; /** @type {string} */ var TEXT_PRINT_TOOLTIP: string; /** @type {string} */ var TEXT_PROMPT_HELPURL: string; /** @type {string} */ var TEXT_PROMPT_TYPE_TEXT: string; /** @type {string} */ var TEXT_PROMPT_TYPE_NUMBER: string; /** @type {string} */ var TEXT_PROMPT_TOOLTIP_NUMBER: string; /** @type {string} */ var TEXT_PROMPT_TOOLTIP_TEXT: string; /** @type {string} */ var TEXT_COUNT_MESSAGE0: string; /** @type {string} */ var TEXT_COUNT_HELPURL: string; /** @type {string} */ var TEXT_COUNT_TOOLTIP: string; /** @type {string} */ var TEXT_REPLACE_MESSAGE0: string; /** @type {string} */ var TEXT_REPLACE_HELPURL: string; /** @type {string} */ var TEXT_REPLACE_TOOLTIP: string; /** @type {string} */ var TEXT_REVERSE_MESSAGE0: string; /** @type {string} */ var TEXT_REVERSE_HELPURL: string; /** @type {string} */ var TEXT_REVERSE_TOOLTIP: string; /** @type {string} */ var LISTS_CREATE_EMPTY_HELPURL: string; /** @type {string} */ var LISTS_CREATE_EMPTY_TITLE: string; /** @type {string} */ var LISTS_CREATE_EMPTY_TOOLTIP: string; /** @type {string} */ var LISTS_CREATE_WITH_HELPURL: string; /** @type {string} */ var LISTS_CREATE_WITH_TOOLTIP: string; /** @type {string} */ var LISTS_CREATE_WITH_INPUT_WITH: string; /** @type {string} */ var LISTS_CREATE_WITH_CONTAINER_TITLE_ADD: string; /** @type {string} */ var LISTS_CREATE_WITH_CONTAINER_TOOLTIP: string; /** @type {string} */ var LISTS_CREATE_WITH_ITEM_TITLE: string; /** @type {string} */ var LISTS_CREATE_WITH_ITEM_TOOLTIP: string; /** @type {string} */ var LISTS_REPEAT_HELPURL: string; /** @type {string} */ var LISTS_REPEAT_TOOLTIP: string; /** @type {string} */ var LISTS_REPEAT_TITLE: string; /** @type {string} */ var LISTS_LENGTH_HELPURL: string; /** @type {string} */ var LISTS_LENGTH_TITLE: string; /** @type {string} */ var LISTS_LENGTH_TOOLTIP: string; /** @type {string} */ var LISTS_ISEMPTY_HELPURL: string; /** @type {string} */ var LISTS_ISEMPTY_TITLE: string; /** @type {string} */ var LISTS_ISEMPTY_TOOLTIP: string; /** @type {string} */ var LISTS_INLIST: string; /** @type {string} */ var LISTS_INDEX_OF_HELPURL: string; /** @type {string} */ var LISTS_INDEX_OF_INPUT_IN_LIST: string; /** @type {string} */ var LISTS_INDEX_OF_FIRST: string; /** @type {string} */ var LISTS_INDEX_OF_LAST: string; /** @type {string} */ var LISTS_INDEX_OF_TOOLTIP: string; /** @type {string} */ var LISTS_GET_INDEX_HELPURL: string; /** @type {string} */ var LISTS_GET_INDEX_GET: string; /** @type {string} */ var LISTS_GET_INDEX_GET_REMOVE: string; /** @type {string} */ var LISTS_GET_INDEX_REMOVE: string; /** @type {string} */ var LISTS_GET_INDEX_FROM_START: string; /** @type {string} */ var LISTS_GET_INDEX_FROM_END: string; /** @type {string} */ var LISTS_GET_INDEX_FIRST: string; /** @type {string} */ var LISTS_GET_INDEX_LAST: string; /** @type {string} */ var LISTS_GET_INDEX_RANDOM: string; /** @type {string} */ var LISTS_GET_INDEX_TAIL: string; /** @type {string} */ var LISTS_GET_INDEX_INPUT_IN_LIST: string; /** @type {string} */ var LISTS_INDEX_FROM_START_TOOLTIP: string; /** @type {string} */ var LISTS_INDEX_FROM_END_TOOLTIP: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_GET_FROM: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_GET_FIRST: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_GET_LAST: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_GET_RANDOM: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST: string; /** @type {string} */ var LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM: string; /** @type {string} */ var LISTS_SET_INDEX_HELPURL: string; /** @type {string} */ var LISTS_SET_INDEX_INPUT_IN_LIST: string; /** @type {string} */ var LISTS_SET_INDEX_SET: string; /** @type {string} */ var LISTS_SET_INDEX_INSERT: string; /** @type {string} */ var LISTS_SET_INDEX_INPUT_TO: string; /** @type {string} */ var LISTS_SET_INDEX_TOOLTIP_SET_FROM: string; /** @type {string} */ var LISTS_SET_INDEX_TOOLTIP_SET_FIRST: string; /** @type {string} */ var LISTS_SET_INDEX_TOOLTIP_SET_LAST: string; /** @type {string} */ var LISTS_SET_INDEX_TOOLTIP_SET_RANDOM: string; /** @type {string} */ var LISTS_SET_INDEX_TOOLTIP_INSERT_FROM: string; /** @type {string} */ var LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST: string; /** @type {string} */ var LISTS_SET_INDEX_TOOLTIP_INSERT_LAST: string; /** @type {string} */ var LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM: string; /** @type {string} */ var LISTS_GET_SUBLIST_HELPURL: string; /** @type {string} */ var LISTS_GET_SUBLIST_INPUT_IN_LIST: string; /** @type {string} */ var LISTS_GET_SUBLIST_START_FROM_START: string; /** @type {string} */ var LISTS_GET_SUBLIST_START_FROM_END: string; /** @type {string} */ var LISTS_GET_SUBLIST_START_FIRST: string; /** @type {string} */ var LISTS_GET_SUBLIST_END_FROM_START: string; /** @type {string} */ var LISTS_GET_SUBLIST_END_FROM_END: string; /** @type {string} */ var LISTS_GET_SUBLIST_END_LAST: string; /** @type {string} */ var LISTS_GET_SUBLIST_TAIL: string; /** @type {string} */ var LISTS_GET_SUBLIST_TOOLTIP: string; /** @type {string} */ var LISTS_SORT_HELPURL: string; /** @type {string} */ var LISTS_SORT_TITLE: string; /** @type {string} */ var LISTS_SORT_TOOLTIP: string; /** @type {string} */ var LISTS_SORT_ORDER_ASCENDING: string; /** @type {string} */ var LISTS_SORT_ORDER_DESCENDING: string; /** @type {string} */ var LISTS_SORT_TYPE_NUMERIC: string; /** @type {string} */ var LISTS_SORT_TYPE_TEXT: string; /** @type {string} */ var LISTS_SORT_TYPE_IGNORECASE: string; /** @type {string} */ var LISTS_SPLIT_HELPURL: string; /** @type {string} */ var LISTS_SPLIT_LIST_FROM_TEXT: string; /** @type {string} */ var LISTS_SPLIT_TEXT_FROM_LIST: string; /** @type {string} */ var LISTS_SPLIT_WITH_DELIMITER: string; /** @type {string} */ var LISTS_SPLIT_TOOLTIP_SPLIT: string; /** @type {string} */ var LISTS_SPLIT_TOOLTIP_JOIN: string; /** @type {string} */ var LISTS_REVERSE_HELPURL: string; /** @type {string} */ var LISTS_REVERSE_MESSAGE0: string; /** @type {string} */ var LISTS_REVERSE_TOOLTIP: string; /** @type {string} */ var ORDINAL_NUMBER_SUFFIX: string; /** @type {string} */ var VARIABLES_GET_HELPURL: string; /** @type {string} */ var VARIABLES_GET_TOOLTIP: string; /** @type {string} */ var VARIABLES_GET_CREATE_SET: string; /** @type {string} */ var VARIABLES_SET_HELPURL: string; /** @type {string} */ var VARIABLES_SET: string; /** @type {string} */ var VARIABLES_SET_TOOLTIP: string; /** @type {string} */ var VARIABLES_SET_CREATE_GET: string; /** @type {string} */ var PROCEDURES_DEFNORETURN_HELPURL: string; /** @type {string} */ var PROCEDURES_DEFNORETURN_TITLE: string; /** @type {string} */ var PROCEDURES_DEFNORETURN_PROCEDURE: string; /** @type {string} */ var PROCEDURES_BEFORE_PARAMS: string; /** @type {string} */ var PROCEDURES_CALL_BEFORE_PARAMS: string; /** @type {string} */ var PROCEDURES_DEFNORETURN_DO: string; /** @type {string} */ var PROCEDURES_DEFNORETURN_TOOLTIP: string; /** @type {string} */ var PROCEDURES_DEFNORETURN_COMMENT: string; /** @type {string} */ var PROCEDURES_DEFRETURN_HELPURL: string; /** @type {string} */ var PROCEDURES_DEFRETURN_TITLE: string; /** @type {string} */ var PROCEDURES_DEFRETURN_PROCEDURE: string; /** @type {string} */ var PROCEDURES_DEFRETURN_DO: string; /** @type {string} */ var PROCEDURES_DEFRETURN_COMMENT: string; /** @type {string} */ var PROCEDURES_DEFRETURN_RETURN: string; /** @type {string} */ var PROCEDURES_DEFRETURN_TOOLTIP: string; /** @type {string} */ var PROCEDURES_ALLOW_STATEMENTS: string; /** @type {string} */ var PROCEDURES_DEF_DUPLICATE_WARNING: string; /** @type {string} */ var PROCEDURES_CALLNORETURN_HELPURL: string; /** @type {string} */ var PROCEDURES_CALLNORETURN_TOOLTIP: string; /** @type {string} */ var PROCEDURES_CALLRETURN_HELPURL: string; /** @type {string} */ var PROCEDURES_CALLRETURN_TOOLTIP: string; /** @type {string} */ var PROCEDURES_MUTATORCONTAINER_TITLE: string; /** @type {string} */ var PROCEDURES_MUTATORCONTAINER_TOOLTIP: string; /** @type {string} */ var PROCEDURES_MUTATORARG_TITLE: string; /** @type {string} */ var PROCEDURES_MUTATORARG_TOOLTIP: string; /** @type {string} */ var PROCEDURES_HIGHLIGHT_DEF: string; /** @type {string} */ var PROCEDURES_CREATE_DO: string; /** @type {string} */ var PROCEDURES_IFRETURN_TOOLTIP: string; /** @type {string} */ var PROCEDURES_IFRETURN_HELPURL: string; /** @type {string} */ var PROCEDURES_IFRETURN_WARNING: string; /** @type {string} */ var WORKSPACE_COMMENT_DEFAULT_TEXT: string; /** @type {string} */ var WORKSPACE_ARIA_LABEL: string; /** @type {string} */ var COLLAPSED_WARNINGS_WARNING: string; /** @type {string} */ var DIALOG_OK: string; /** @type {string} */ var DIALOG_CANCEL: string; }