blockly 12.4.0 → 12.5.0

package/core/utils/xml.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Injected dependencies.  By default these are just (and have the
+ * same types as) the corresponding DOM Window properties, but the
+ * Node.js wrapper for Blockly (see scripts/package/node/core.js)
+ * calls injectDependencies to supply implementations from the jsdom
+ * package instead.
+ */
+declare let DOMParser: {
+    new (): DOMParser;
+    prototype: DOMParser;
+}, XMLSerializer: {
+    new (): XMLSerializer;
+    prototype: XMLSerializer;
+};
+/**
+ * Inject implementations of document, DOMParser and/or XMLSerializer
+ * to use instead of the default ones.
+ *
+ * Used by the Node.js wrapper for Blockly (see
+ * scripts/package/node/core.js) to supply implementations from the
+ * jsdom package instead.
+ *
+ * While they may be set individually, it is normally the case that
+ * all three will be sourced from the same JSDOM instance.  They MUST
+ * at least come from the same copy of the jsdom package.  (Typically
+ * this is hard to avoid satsifying this requirement, but it can be
+ * inadvertently violated by using webpack to build multiple bundles
+ * containing Blockly and jsdom, and then loading more than one into
+ * the same JavaScript runtime.  See
+ * https://github.com/google/blockly-samples/pull/1452#issuecomment-1364442135
+ * for an example of how this happened.)
+ *
+ * @param dependencies Options object containing dependencies to set.
+ */
+export declare function injectDependencies(dependencies: {
+    document?: Document;
+    DOMParser?: typeof DOMParser;
+    XMLSerializer?: typeof XMLSerializer;
+}): void;
+/**
+ * Namespace for Blockly's XML.
+ */
+export declare const NAME_SPACE = "https://developers.google.com/blockly/xml";
+/**
+ * Create DOM element for XML.
+ *
+ * @param tagName Name of DOM element.
+ * @returns New DOM element.
+ */
+export declare function createElement(tagName: string): Element;
+/**
+ * Create text element for XML.
+ *
+ * @param text Text content.
+ * @returns New DOM text node.
+ */
+export declare function createTextNode(text: string): Text;
+/**
+ * Converts an XML string into a DOM structure.
+ *
+ * Control characters should be escaped. (But we will try to best-effort parse
+ * unescaped characters.)
+ *
+ * Note that even when escaped, U+0000 will be parsed as U+FFFD (the
+ * "replacement character") because U+0000 is never a valid XML character
+ * (even in XML 1.1).
+ * https://www.w3.org/TR/xml11/#charsets
+ *
+ * @param text An XML string.
+ * @returns A DOM object representing the singular child of the document
+ *     element.
+ * @throws if the text doesn't parse.
+ */
+export declare function textToDom(text: string): Element;
+/**
+ * Converts a DOM structure into plain text.
+ * Currently the text format is fairly ugly: all one line with no whitespace.
+ *
+ * Control characters are escaped using their decimal encodings. This includes
+ * U+0000 even though it is technically never a valid XML character (even in
+ * XML 1.1).
+ * https://www.w3.org/TR/xml11/#charsets
+ *
+ * When decoded U+0000 will be parsed as U+FFFD (the "replacement character").
+ *
+ * @param dom A tree of XML nodes.
+ * @returns Text representation.
+ */
+export declare function domToText(dom: Node): string;
+export {};
+//# sourceMappingURL=xml.d.ts.map

package/core/utils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as browserEvents from './browser_events.js';
+import * as extensions from './extensions.js';
+import * as aria from './utils/aria.js';
+import * as arrayUtils from './utils/array.js';
+import * as colour from './utils/colour.js';
+import { Coordinate } from './utils/coordinate.js';
+import * as deprecation from './utils/deprecation.js';
+import * as dom from './utils/dom.js';
+import * as idGenerator from './utils/idgenerator.js';
+import { KeyCodes } from './utils/keycodes.js';
+import * as math from './utils/math.js';
+import type { Metrics } from './utils/metrics.js';
+import * as object from './utils/object.js';
+import * as parsing from './utils/parsing.js';
+import { Rect } from './utils/rect.js';
+import { Size } from './utils/size.js';
+import * as stringUtils from './utils/string.js';
+import * as style from './utils/style.js';
+import { Svg } from './utils/svg.js';
+import * as svgMath from './utils/svg_math.js';
+import * as svgPaths from './utils/svg_paths.js';
+import * as toolbox from './utils/toolbox.js';
+import * as userAgent from './utils/useragent.js';
+import * as xml from './utils/xml.js';
+export { aria, arrayUtils as array, browserEvents, colour, Coordinate, deprecation, dom, extensions, idGenerator, KeyCodes, math, Metrics, object, parsing, Rect, Size, stringUtils as string, style, Svg, svgMath, svgPaths, toolbox, userAgent, xml, };
+//# sourceMappingURL=utils.d.ts.map

package/core/variable_map.d.ts

@@ -0,0 +1,164 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Object representing a map of variables and their types.
+ *
+ * @class
+ */
+import './events/events_var_delete.js';
+import './events/events_var_rename.js';
+import type { Block } from './block.js';
+import type { IVariableMap } from './interfaces/i_variable_map.js';
+import { IVariableModel, IVariableState } from './interfaces/i_variable_model.js';
+import type { Workspace } from './workspace.js';
+/**
+ * Class for a variable map.  This contains a dictionary data structure with
+ * variable types as keys and lists of variables as values.  The list of
+ * variables are the type indicated by the key.
+ */
+export declare class VariableMap implements IVariableMap<IVariableModel<IVariableState>> {
+    workspace: Workspace;
+    potentialMap: boolean;
+    /**
+     * A map from variable type to map of IDs to variables. The maps contain
+     * all of the named variables in the workspace, including variables that are
+     * not currently in use.
+     */
+    private variableMap;
+    /**
+     * @param workspace The workspace this map belongs to.
+     * @param potentialMap True if this holds variables that don't exist in the
+     *  workspace yet.
+     */
+    constructor(workspace: Workspace, potentialMap?: boolean);
+    /** Clear the variable map.  Fires events for every deletion. */
+    clear(): void;
+    /**
+     * Rename the given variable by updating its name in the variable map.
+     *
+     * @param variable Variable to rename.
+     * @param newName New variable name.
+     * @returns The newly renamed variable.
+     */
+    renameVariable(variable: IVariableModel<IVariableState>, newName: string): IVariableModel<IVariableState>;
+    changeVariableType(variable: IVariableModel<IVariableState>, newType: string): IVariableModel<IVariableState>;
+    /**
+     * Rename a variable by updating its name in the variable map. Identify the
+     * variable to rename with the given ID.
+     *
+     * @deprecated v12: use VariableMap.renameVariable.
+     * @param id ID of the variable to rename.
+     * @param newName New variable name.
+     */
+    renameVariableById(id: string, newName: string): void;
+    /**
+     * Update the name of the given variable and refresh all references to it.
+     * The new name must not conflict with any existing variable names.
+     *
+     * @param variable Variable to rename.
+     * @param newName New variable name.
+     * @param blocks The list of all blocks in the workspace.
+     */
+    private renameVariableAndUses;
+    /**
+     * Update the name of the given variable to the same name as an existing
+     * variable.  The two variables are coalesced into a single variable with the
+     * ID of the existing variable that was already using newName. Refresh all
+     * references to the variable.
+     *
+     * @param variable Variable to rename.
+     * @param newName New variable name.
+     * @param conflictVar The variable that was already using newName.
+     * @param blocks The list of all blocks in the workspace.
+     */
+    private renameVariableWithConflict;
+    /**
+     * Create a variable with a given name, optional type, and optional ID.
+     *
+     * @param name The name of the variable. This must be unique across variables
+     *     and procedures.
+     * @param opt_type The type of the variable like 'int' or 'string'.
+     *     Does not need to be unique. Field_variable can filter variables based
+     * on their type. This will default to '' which is a specific type.
+     * @param opt_id The unique ID of the variable. This will default to a UUID.
+     * @returns The newly created variable.
+     */
+    createVariable(name: string, opt_type?: string, opt_id?: string): IVariableModel<IVariableState>;
+    /**
+     * Adds the given variable to this variable map.
+     *
+     * @param variable The variable to add.
+     */
+    addVariable(variable: IVariableModel<IVariableState>): void;
+    /**
+     * Delete a variable and all of its uses without confirmation.
+     *
+     * @param variable Variable to delete.
+     */
+    deleteVariable(variable: IVariableModel<IVariableState>): void;
+    /**
+     * Delete a variables by the passed in ID and all of its uses from this
+     * workspace. May prompt the user for confirmation.
+     *
+     * @deprecated v12: use Blockly.Variables.deleteVariable.
+     * @param id ID of variable to delete.
+     */
+    deleteVariableById(id: string): void;
+    /**
+     * Find the variable by the given name and type and return it.  Return null if
+     *     it is not found.
+     *
+     * @param name The name to check for.
+     * @param opt_type The type of the variable.  If not provided it defaults to
+     *     the empty string, which is a specific type.
+     * @returns The variable with the given name, or null if it was not found.
+     */
+    getVariable(name: string, opt_type?: string): IVariableModel<IVariableState> | null;
+    /**
+     * Find the variable by the given ID and return it.  Return null if not found.
+     *
+     * @param id The ID to check for.
+     * @returns The variable with the given ID.
+     */
+    getVariableById(id: string): IVariableModel<IVariableState> | null;
+    /**
+     * Get a list containing all of the variables of a specified type. If type is
+     *     null, return list of variables with empty string type.
+     *
+     * @param type Type of the variables to find.
+     * @returns The sought after variables of the passed in type. An empty array
+     *     if none are found.
+     */
+    getVariablesOfType(type: string | null): IVariableModel<IVariableState>[];
+    /**
+     * Returns a list of unique types of variables in this variable map.
+     *
+     * @returns A list of unique types of variables in this variable map.
+     */
+    getTypes(): string[];
+    /**
+     * Return all variables of all types.
+     *
+     * @returns List of variable models.
+     */
+    getAllVariables(): IVariableModel<IVariableState>[];
+    /**
+     * Returns all of the variable names of all types.
+     *
+     * @deprecated v12: use Blockly.Variables.getAllVariables.
+     * @returns All of the variable names of all types.
+     */
+    getAllVariableNames(): string[];
+    /**
+     * Find all the uses of a named variable.
+     *
+     * @deprecated v12: use Blockly.Variables.getVariableUsesById.
+     * @param id ID of the variable to find.
+     * @returns Array of block usages.
+     */
+    getVariableUsesById(id: string): Block[];
+}
+//# sourceMappingURL=variable_map.d.ts.map

package/core/variable_model.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Components for the variable model.
+ *
+ * @class
+ */
+import './events/events_var_create.js';
+import { IVariableModel, IVariableState } from './interfaces/i_variable_model.js';
+import type { Workspace } from './workspace.js';
+/**
+ * Class for a variable model.
+ * Holds information for the variable including name, ID, and type.
+ *
+ * @see {Blockly.FieldVariable}
+ */
+export declare class VariableModel implements IVariableModel<IVariableState> {
+    private readonly workspace;
+    private name;
+    private type;
+    private readonly id;
+    /**
+     * @param workspace The variable's workspace.
+     * @param name The name of the variable.  This is the user-visible name (e.g.
+     *     'my var' or '私の変数'), not the generated name.
+     * @param opt_type The type of the variable like 'int' or 'string'.
+     *     Does not need to be unique. Field_variable can filter variables based
+     * on their type. This will default to '' which is a specific type.
+     * @param opt_id The unique ID of the variable. This will default to a UUID.
+     */
+    constructor(workspace: Workspace, name: string, opt_type?: string, opt_id?: string);
+    /** @returns The ID for the variable. */
+    getId(): string;
+    /** @returns The name of this variable. */
+    getName(): string;
+    /**
+     * Updates the user-visible name of this variable.
+     *
+     * @returns The newly-updated variable.
+     */
+    setName(newName: string): this;
+    /** @returns The type of this variable. */
+    getType(): string;
+    /**
+     * Updates the type of this variable.
+     *
+     * @returns The newly-updated variable.
+     */
+    setType(newType: string): this;
+    /**
+     * Returns the workspace this VariableModel belongs to.
+     *
+     * @returns The workspace this VariableModel belongs to.
+     */
+    getWorkspace(): Workspace;
+    /**
+     * Serializes this VariableModel.
+     *
+     * @returns a JSON representation of this VariableModel.
+     */
+    save(): IVariableState;
+    /**
+     * Loads the persisted state into a new variable in the given workspace.
+     *
+     * @param state The serialized state of a variable model from save().
+     * @param workspace The workspace to create the new variable in.
+     */
+    static load(state: IVariableState, workspace: Workspace): void;
+}
+//# sourceMappingURL=variable_model.d.ts.map

package/core/variables.d.ts

@@ -0,0 +1,238 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Block } from './block.js';
+import { IVariableModel, IVariableState } from './interfaces/i_variable_model.js';
+import type { BlockInfo, FlyoutItemInfo } from './utils/toolbox.js';
+import type { Workspace } from './workspace.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * String for use in the "custom" attribute of a category in toolbox XML.
+ * This string indicates that the category should be dynamically populated with
+ * variable blocks.
+ * See also Blockly.Procedures.CATEGORY_NAME and
+ * Blockly.VariablesDynamic.CATEGORY_NAME.
+ */
+export declare const CATEGORY_NAME = "VARIABLE";
+/**
+ * Find all user-created variables that are in use in the workspace.
+ * For use by generators.
+ *
+ * To get a list of all variables on a workspace, including unused variables,
+ * call getAllVariables.
+ *
+ * @param ws The workspace to search for variables.
+ * @returns Array of variable models.
+ */
+export declare function allUsedVarModels(ws: Workspace): IVariableModel<IVariableState>[];
+/**
+ * Find all developer variables used by blocks in the workspace.
+ *
+ * Developer variables are never shown to the user, but are declared as global
+ * variables in the generated code.
+ * To declare developer variables, define the getDeveloperVariables function on
+ * your block and return a list of variable names.
+ * For use by generators.
+ *
+ * @param workspace The workspace to search.
+ * @returns A list of non-duplicated variable names.
+ */
+export declare function allDeveloperVariables(workspace: Workspace): string[];
+/**
+ * Internal wrapper that returns the contents of the variables category.
+ *
+ * @internal
+ * @param workspace The workspace to populate variable blocks for.
+ */
+export declare function internalFlyoutCategory(workspace: WorkspaceSvg): FlyoutItemInfo[];
+export declare function flyoutCategory(workspace: WorkspaceSvg, useXml: true): Element[];
+export declare function flyoutCategory(workspace: WorkspaceSvg, useXml: false): FlyoutItemInfo[];
+/**
+ * Construct the blocks required by the flyout for the variable category.
+ *
+ * @internal
+ * @param workspace The workspace containing variables.
+ * @param variables List of variables to create blocks for.
+ * @param includeChangeBlocks True to include `change x by _` blocks.
+ * @param getterType The type of the variable getter block to generate.
+ * @param setterType The type of the variable setter block to generate.
+ * @returns JSON list of blocks.
+ */
+export declare function jsonFlyoutCategoryBlocks(workspace: Workspace, variables: IVariableModel<IVariableState>[], includeChangeBlocks: boolean, getterType?: string, setterType?: string): BlockInfo[];
+/**
+ * Construct the blocks required by the flyout for the variable category.
+ *
+ * @param workspace The workspace containing variables.
+ * @returns Array of XML block elements.
+ */
+export declare function flyoutCategoryBlocks(workspace: Workspace): Element[];
+export declare const VAR_LETTER_OPTIONS = "ijkmnopqrstuvwxyzabcdefgh";
+/**
+ * Return a new variable name that is not yet being used. This will try to
+ * generate single letter variable names in the range 'i' to 'z' to start with.
+ * If no unique name is located it will try 'i' to 'z', 'a' to 'h',
+ * then 'i2' to 'z2' etc.  Skip 'l'.
+ *
+ * @param workspace The workspace to be unique in.
+ * @returns New variable name.
+ */
+export declare function generateUniqueName(workspace: Workspace): string;
+/**
+ * Private version of generateUniqueName for stubbing in tests.
+ */
+declare function generateUniqueNameInternal(workspace: Workspace): string;
+/**
+ * Returns a unique name that is not present in the usedNames array. This
+ * will try to generate single letter names in the range a - z (skip l). It
+ * will start with the character passed to startChar.
+ *
+ * @param startChar The character to start the search at.
+ * @param usedNames A list of all of the used names.
+ * @returns A unique name that is not present in the usedNames array.
+ */
+export declare function generateUniqueNameFromOptions(startChar: string, usedNames: string[]): string;
+/**
+ * Handles "Create Variable" button in the default variables toolbox category.
+ * It will prompt the user for a variable name, including re-prompts if a name
+ * is already in use among the workspace's variables.
+ *
+ * Custom button handlers can delegate to this function, allowing variables
+ * types and after-creation processing. More complex customization (e.g.,
+ * prompting for variable type) is beyond the scope of this function.
+ *
+ * @param workspace The workspace on which to create the variable.
+ * @param opt_callback A callback. It will be passed an acceptable new variable
+ *     name, or null if change is to be aborted (cancel button), or undefined if
+ *     an existing variable was chosen.
+ * @param opt_type The type of the variable like 'int', 'string', or ''. This
+ *     will default to '', which is a specific type.
+ */
+export declare function createVariableButtonHandler(workspace: Workspace, opt_callback?: (p1?: string | null) => void, opt_type?: string): void;
+/**
+ * Opens a prompt that allows the user to enter a new name for a variable.
+ * Triggers a rename if the new name is valid. Or re-prompts if there is a
+ * collision.
+ *
+ * @param workspace The workspace on which to rename the variable.
+ * @param variable Variable to rename.
+ * @param opt_callback A callback. It will be passed an acceptable new variable
+ *     name, or null if change is to be aborted (cancel button), or undefined if
+ *     an existing variable was chosen.
+ */
+export declare function renameVariable(workspace: Workspace, variable: IVariableModel<IVariableState>, opt_callback?: (p1?: string | null) => void): void;
+/**
+ * Prompt the user for a new variable name.
+ *
+ * @param promptText The string of the prompt.
+ * @param defaultText The default value to show in the prompt's field.
+ * @param callback A callback. It will be passed the new variable name, or null
+ *     if the user picked something illegal.
+ */
+export declare function promptName(promptText: string, defaultText: string, callback: (p1: string | null) => void): void;
+/**
+ * Check whether there exists a variable with the given name of any type.
+ *
+ * @param name The name to search for.
+ * @param workspace The workspace to search for the variable.
+ * @returns The variable with the given name, or null if none was found.
+ */
+export declare function nameUsedWithAnyType(name: string, workspace: Workspace): IVariableModel<IVariableState> | null;
+/**
+ * Returns the name of the procedure with a conflicting parameter name, or null
+ * if one does not exist.
+ *
+ * This checks the procedure map if it contains models, and the legacy procedure
+ * blocks otherwise.
+ *
+ * @param oldName The old name of the variable.
+ * @param newName The proposed name of the variable.
+ * @param workspace The workspace to search for conflicting parameters.
+ * @internal
+ */
+export declare function nameUsedWithConflictingParam(oldName: string, newName: string, workspace: Workspace): string | null;
+/**
+ * Generate DOM objects representing a variable field.
+ *
+ * @param variableModel The variable model to represent.
+ * @returns The generated DOM.
+ */
+export declare function generateVariableFieldDom(variableModel: IVariableModel<IVariableState>): Element;
+/**
+ * Helper function to look up or create a variable on the given workspace.
+ * If no variable exists, creates and returns it.
+ *
+ * @param workspace The workspace to search for the variable.  It may be a
+ *     flyout workspace or main workspace.
+ * @param id The ID to use to look up or create the variable, or null.
+ * @param opt_name The string to use to look up or create the variable.
+ * @param opt_type The type to use to look up or create the variable.
+ * @returns The variable corresponding to the given ID or name + type
+ *     combination.
+ */
+export declare function getOrCreateVariablePackage(workspace: Workspace, id: string | null, opt_name?: string, opt_type?: string): IVariableModel<IVariableState>;
+/**
+ * Look up  a variable on the given workspace.
+ * Always looks in the main workspace before looking in the flyout workspace.
+ * Always prefers lookup by ID to lookup by name + type.
+ *
+ * @param workspace The workspace to search for the variable.  It may be a
+ *     flyout workspace or main workspace.
+ * @param id The ID to use to look up the variable, or null.
+ * @param opt_name The string to use to look up the variable.
+ *     Only used if lookup by ID fails.
+ * @param opt_type The type to use to look up the variable.
+ *     Only used if lookup by ID fails.
+ * @returns The variable corresponding to the given ID or name + type
+ *     combination, or null if not found.
+ */
+export declare function getVariable(workspace: Workspace, id: string | null, opt_name?: string, opt_type?: string): IVariableModel<IVariableState> | null;
+/**
+ * Helper function to get the list of variables that have been added to the
+ * workspace after adding a new block, using the given list of variables that
+ * were in the workspace before the new block was added.
+ *
+ * @param workspace The workspace to inspect.
+ * @param originalVariables The array of variables that existed in the workspace
+ *     before adding the new block.
+ * @returns The new array of variables that were freshly added to the workspace
+ *     after creating the new block, or [] if no new variables were added to the
+ *     workspace.
+ * @internal
+ */
+export declare function getAddedVariables(workspace: Workspace, originalVariables: IVariableModel<IVariableState>[]): IVariableModel<IVariableState>[];
+/**
+ * A custom compare function for the VariableModel objects.
+ *
+ * @param var1 First variable to compare.
+ * @param var2 Second variable to compare.
+ * @returns -1 if name of var1 is less than name of var2, 0 if equal, and 1 if
+ *     greater.
+ * @internal
+ */
+export declare function compareByName(var1: IVariableModel<IVariableState>, var2: IVariableModel<IVariableState>): number;
+/**
+ * Find all the uses of a named variable.
+ *
+ * @param workspace The workspace to search for the variable.
+ * @param id ID of the variable to find.
+ * @returns Array of block usages.
+ */
+export declare function getVariableUsesById(workspace: Workspace, id: string): Block[];
+/**
+ * Delete a variable and all of its uses from the given workspace. May prompt
+ * the user for confirmation.
+ *
+ * @param workspace The workspace from which to delete the variable.
+ * @param variable The variable to delete.
+ * @param triggeringBlock The block from which this deletion was triggered, if
+ *     any. Used to exclude it from checking and warning about blocks
+ *     referencing the variable being deleted.
+ */
+export declare function deleteVariable(workspace: Workspace, variable: IVariableModel<IVariableState>, triggeringBlock?: Block): void;
+export declare const TEST_ONLY: {
+    generateUniqueNameInternal: typeof generateUniqueNameInternal;
+};
+export {};
+//# sourceMappingURL=variables.d.ts.map

package/core/variables_dynamic.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FlyoutButton } from './flyout_button.js';
+import type { FlyoutItemInfo } from './utils/toolbox.js';
+import type { Workspace } from './workspace.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * String for use in the "custom" attribute of a category in toolbox XML.
+ * This string indicates that the category should be dynamically populated with
+ * variable blocks.
+ * See also Blockly.Variables.CATEGORY_NAME and
+ * Blockly.Procedures.CATEGORY_NAME.
+ */
+export declare const CATEGORY_NAME = "VARIABLE_DYNAMIC";
+/**
+ * Click handler for a button that creates String variables.
+ *
+ * @param button
+ */
+declare function stringButtonClickHandler(button: FlyoutButton): void;
+export declare const onCreateVariableButtonClick_String: typeof stringButtonClickHandler;
+/**
+ * Click handler for a button that creates Number variables.
+ *
+ * @param button
+ */
+declare function numberButtonClickHandler(button: FlyoutButton): void;
+export declare const onCreateVariableButtonClick_Number: typeof numberButtonClickHandler;
+/**
+ * Click handler for a button that creates Colour variables.
+ *
+ * @param button
+ */
+declare function colourButtonClickHandler(button: FlyoutButton): void;
+export declare const onCreateVariableButtonClick_Colour: typeof colourButtonClickHandler;
+/**
+ * Internal wrapper that returns the contents of the dynamic variables category.
+ *
+ * @internal
+ * @param workspace The workspace to populate variable blocks for.
+ */
+export declare function internalFlyoutCategory(workspace: WorkspaceSvg): FlyoutItemInfo[];
+export declare function flyoutCategory(workspace: WorkspaceSvg, useXml: true): Element[];
+export declare function flyoutCategory(workspace: WorkspaceSvg, useXml: false): FlyoutItemInfo[];
+/**
+ * Construct the blocks required by the flyout for the variable category.
+ *
+ * @param workspace The workspace containing variables.
+ * @returns Array of XML block elements.
+ */
+export declare function flyoutCategoryBlocks(workspace: Workspace): Element[];
+export {};
+//# sourceMappingURL=variables_dynamic.d.ts.map