pxt-core 10.0.2 → 10.0.4

package/built/pxtblocks/fields/field_gridpicker.d.ts

@@ -0,0 +1,109 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustom, FieldCustomDropdownOptions } from "./field_utils";
+export interface FieldGridPickerToolTipConfig {
+    yOffset?: number;
+    xOffset?: number;
+}
+export interface FieldGridPickerOptions extends FieldCustomDropdownOptions {
+    columns?: string;
+    maxRows?: string;
+    width?: string;
+    tooltips?: string;
+    tooltipsXOffset?: string;
+    tooltipsYOffset?: string;
+    hasSearchBar?: boolean;
+    hideRect?: boolean;
+}
+export declare class FieldGridPicker extends Blockly.FieldDropdown implements FieldCustom {
+    isFieldCustom_: boolean;
+    private width_;
+    private columns_;
+    private maxRows_;
+    protected backgroundColour_: string;
+    protected borderColour_: string;
+    private tooltipConfig_;
+    private gridTooltip_;
+    private firstItem_;
+    private hasSearchBar_;
+    private hideRect_;
+    private observer;
+    private selectedItemDom;
+    private closeModal_;
+    private selectedBar_;
+    private selectedImg_;
+    private selectedBarText_;
+    private selectedBarValue_;
+    private static DEFAULT_IMG;
+    constructor(text: string, options: FieldGridPickerOptions, validator?: Function);
+    /**
+     * When disposing the grid picker, make sure the tooltips are disposed too.
+     * @public
+     */
+    dispose(): void;
+    private createTooltip_;
+    /**
+     * Create blocklyGridPickerRows and add them to table container
+     * @param options
+     * @param tableContainer
+     */
+    private populateTableContainer;
+    /**
+     * Populate a single row and add it to table container
+     * @param row
+     * @param options
+     * @param tableContainer
+     */
+    private populateRow;
+    /**
+     * Callback for when a button is clicked inside the drop-down.
+     * Should be bound to the FieldIconMenu.
+     * @param {Event} e DOM event for the click/touch
+     * @private
+     */
+    protected buttonClick_: (e: any) => void;
+    protected buttonClickAndClose_: (e: any) => void;
+    /**
+     * Whether or not to show a box around the dropdown menu.
+     * @return {boolean} True if we should show a box (rect) around the dropdown menu. Otherwise false.
+     * @private
+     */
+    shouldShowRect_(): boolean;
+    doClassValidation_(newValue: string): string;
+    /**
+     * Closes the gridpicker.
+     */
+    private close;
+    /**
+     * Getter method
+     */
+    private getFirstItem;
+    /**
+     * Highlight first item in menu, de-select and de-highlight all others
+     */
+    private highlightFirstItem;
+    /**
+     * Scroll menu to item that equals current value of gridpicker
+     */
+    private highlightAndScrollSelected;
+    /**
+     * Create a dropdown menu under the text.
+     * @private
+     */
+    showEditor_(): void;
+    private positionMenu_;
+    private shouldShowTooltips;
+    private getAnchorDimensions_;
+    private createWidget_;
+    private createSearchBar_;
+    private createSelectedBar_;
+    private updateSelectedBar_;
+    private setupIntersectionObserver_;
+    private disposeIntersectionObserver;
+    /**
+     * Disposes the tooltip DOM.
+     * @private
+     */
+    private disposeTooltip;
+    private onClose_;
+}

package/built/pxtblocks/fields/field_imagedropdown.d.ts

@@ -0,0 +1,35 @@
+/// <reference path="../../pxtlib.d.ts" />
+import { FieldCustom, FieldCustomDropdownOptions } from "./field_utils";
+import { FieldDropdown } from "./field_dropdown";
+export interface FieldImageDropdownOptions extends FieldCustomDropdownOptions {
+    columns?: string;
+    maxRows?: string;
+    width?: string;
+}
+export declare class FieldImageDropdown extends FieldDropdown implements FieldCustom {
+    isFieldCustom_: boolean;
+    protected width_: number;
+    protected columns_: number;
+    protected maxRows_: number;
+    protected backgroundColour_: string;
+    protected borderColour_: string;
+    protected savedPrimary_: string;
+    constructor(text: string, options: FieldImageDropdownOptions, validator?: Function);
+    /**
+     * Create a dropdown menu under the text.
+     * @private
+     */
+    showEditor_(): void;
+    doValueUpdate_(newValue: any): void;
+    /**
+     * Callback for when a button is clicked inside the drop-down.
+     * Should be bound to the FieldIconMenu.
+     * @param {Event} e DOM event for the click/touch
+     * @private
+     */
+    protected buttonClick_: (e: MouseEvent) => void;
+    /**
+     * Callback for when the drop-down is hidden.
+     */
+    protected onHide_(): void;
+}

package/built/pxtblocks/fields/field_images.d.ts

@@ -0,0 +1,20 @@
+/// <reference path="../../pxtlib.d.ts" />
+import { FieldImageDropdown, FieldImageDropdownOptions } from "./field_imagedropdown";
+import { FieldCustom } from "./field_utils";
+export interface FieldImagesOptions extends FieldImageDropdownOptions {
+    sort?: boolean;
+    addLabel?: string;
+}
+export declare class FieldImages extends FieldImageDropdown implements FieldCustom {
+    isFieldCustom_: boolean;
+    private shouldSort_;
+    protected addLabel_: boolean;
+    constructor(text: string, options: FieldImagesOptions, validator?: Function);
+    /**
+     * Create a dropdown menu under the text.
+     * @private
+     */
+    showEditor_(): void;
+    protected onHideCallback(): void;
+    protected createTextNode_(text: string): HTMLSpanElement;
+}

package/built/pxtblocks/fields/field_kind.d.ts

@@ -0,0 +1,12 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldDropdown } from "./field_dropdown";
+export declare class FieldKind extends FieldDropdown {
+    private opts;
+    constructor(opts: pxtc.KindInfo);
+    initView(): void;
+    onItemSelected_(menu: Blockly.Menu, menuItem: Blockly.MenuItem): void;
+    doClassValidation_(value: any): string;
+    getOptions(opt_useCache?: boolean): Blockly.MenuOption[];
+    private initVariables;
+}

package/built/pxtblocks/fields/field_ledmatrix.d.ts

@@ -0,0 +1,52 @@
+/// <reference path="../../pxtlib.d.ts" />
+/// <reference path="../../pxtsim.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustom } from "./field_utils";
+export declare class FieldMatrix extends Blockly.Field implements FieldCustom {
+    private static CELL_WIDTH;
+    private static CELL_HORIZONTAL_MARGIN;
+    private static CELL_VERTICAL_MARGIN;
+    private static CELL_CORNER_RADIUS;
+    private static BOTTOM_MARGIN;
+    private static Y_AXIS_WIDTH;
+    private static X_AXIS_HEIGHT;
+    private static TAB;
+    isFieldCustom_: boolean;
+    SERIALIZABLE: boolean;
+    private params;
+    private onColor;
+    private offColor;
+    private static DEFAULT_OFF_COLOR;
+    private scale;
+    private matrixWidth;
+    private matrixHeight;
+    private yAxisLabel;
+    private xAxisLabel;
+    private cellState;
+    private cells;
+    private elt;
+    private currentDragState_;
+    constructor(text: string, params: any, validator?: Blockly.FieldValidator);
+    /**
+     * Show the inline free-text editor on top of the text.
+     * @private
+     */
+    showEditor_(): void;
+    private initMatrix;
+    private getLabel;
+    private dontHandleMouseEvent_;
+    private clearLedDragHandler;
+    private createCell;
+    private toggleRect;
+    private handleRootMouseMoveListener;
+    private getColor;
+    private getOpacity;
+    private updateCell;
+    setValue(newValue: string | number, restoreState?: boolean): void;
+    render_(): void;
+    getValue(): string;
+    private restoreStateFromString;
+    private updateValue;
+    private getYAxisWidth;
+    private getXAxisHeight;
+}

package/built/pxtblocks/fields/field_melodySandbox.d.ts

@@ -0,0 +1,89 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import svg = pxt.svgUtil;
+import { FieldCustom, FieldCustomOptions } from "./field_utils";
+export declare const HEADER_HEIGHT = 50;
+export declare const TOTAL_WIDTH = 300;
+export declare class FieldCustomMelody<U extends FieldCustomOptions> extends Blockly.Field implements FieldCustom {
+    isFieldCustom_: boolean;
+    SERIALIZABLE: boolean;
+    protected params: U;
+    private melody;
+    private soundingKeys;
+    private numRow;
+    private numCol;
+    private tempo;
+    private stringRep;
+    private isPlaying;
+    private timeouts;
+    private invalidString;
+    private prevString;
+    private topDiv;
+    private editorDiv;
+    private gridDiv;
+    private bottomDiv;
+    private doneButton;
+    private playButton;
+    private playIcon;
+    private tempoInput;
+    private static CELL_WIDTH;
+    private static CELL_HORIZONTAL_MARGIN;
+    private static CELL_VERTICAL_MARGIN;
+    private static CELL_CORNER_RADIUS;
+    private elt;
+    private cells;
+    private static VIEWBOX_WIDTH;
+    private static VIEWBOX_HEIGHT;
+    private static COLOR_BLOCK_WIDTH;
+    private static COLOR_BLOCK_HEIGHT;
+    private static COLOR_BLOCK_X;
+    private static COLOR_BLOCK_Y;
+    private static COLOR_BLOCK_SPACING;
+    private static MUSIC_ICON_WIDTH;
+    private toggle;
+    private root;
+    private gallery;
+    constructor(value: string, params: U, validator?: Blockly.FieldValidator);
+    init(): void;
+    showEditor_(): void;
+    getValue(): string;
+    doValueUpdate_(newValue: string): void;
+    getText_(): string;
+    protected onInit(): void;
+    render_(): void;
+    protected renderEditor(div: HTMLDivElement): void;
+    protected onEditorClose(): void;
+    private onDone;
+    private clearDomReferences;
+    protected getTypeScriptValue(): string;
+    protected parseTypeScriptValue(value: string): void;
+    private isValidNote;
+    protected getPreviewWidth(): number;
+    protected getPreviewHeight(): number;
+    protected getDropdownBackgroundColour(): string;
+    protected getDropdownBorderColour(): string;
+    private updateFieldLabel;
+    private setTempo;
+    private syncTempoField;
+    private getDuration;
+    private createMelodyIfDoesntExist;
+    private onNoteSelect;
+    private updateGrid;
+    private playNote;
+    protected queueToneForColumn(column: number, delay: number, duration: number): void;
+    protected playToneCore(row: number): void;
+    private highlightColumn;
+    private createGridDisplay;
+    private createCell;
+    private togglePlay;
+    private updatePlayButton;
+    private playMelody;
+    private stopMelody;
+    private showGallery;
+    private hideGallery;
+}
+export interface ButtonGroup {
+    root: svg.Group;
+    cx: number;
+    cy: number;
+}

package/built/pxtblocks/fields/field_musiceditor.d.ts

@@ -0,0 +1,16 @@
+/// <reference path="../../pxtlib.d.ts" />
+import { FieldAssetEditor } from "./field_asset";
+export interface FieldMusicEditorOptions {
+}
+interface ParsedFieldMusicEditorOptions {
+}
+export declare class FieldMusicEditor extends FieldAssetEditor<FieldMusicEditorOptions, ParsedFieldMusicEditorOptions> {
+    protected getAssetType(): pxt.AssetType;
+    protected createNewAsset(text?: string): pxt.Asset;
+    render_(): void;
+    protected getValueText(): string;
+    protected parseFieldOptions(opts: FieldMusicEditorOptions): ParsedFieldMusicEditorOptions;
+    protected redrawPreview(): void;
+    protected previewWidth(): number;
+}
+export {};

package/built/pxtblocks/fields/field_note.d.ts

@@ -0,0 +1,117 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustomOptions, FieldCustom } from "./field_utils";
+export interface FieldNoteOptions extends FieldCustomOptions {
+    editorColour?: string;
+    minNote?: string;
+    maxNote?: string;
+    eps?: string;
+}
+export declare class FieldNote extends Blockly.FieldNumber implements FieldCustom {
+    isFieldCustom_: boolean;
+    SERIALIZABLE: boolean;
+    isTextValid_: boolean;
+    private static Notes;
+    protected static readonly keyWidth = 22;
+    protected static readonly keyHeight = 90;
+    protected static readonly labelHeight = 24;
+    protected static readonly prevNextHeight = 20;
+    protected static readonly notesPerOctave = 12;
+    protected static readonly blackKeysPerOctave = 5;
+    /**
+     * default number of piano keys
+     */
+    protected nKeys_: number;
+    protected minNote_: number;
+    protected maxNote_: number;
+    /** Absolute error for note frequency identification (Hz) **/
+    protected eps: number;
+    protected primaryColour: string;
+    protected borderColour: string;
+    protected isExpanded: Boolean;
+    protected totalPlayCount: number;
+    protected currentPage: number;
+    protected piano: HTMLDivElement[];
+    protected noteLabel: HTMLDivElement;
+    protected currentSelectedKey: HTMLDivElement;
+    constructor(text: string, params: FieldNoteOptions, validator?: Blockly.FieldValidator);
+    /**
+     * Ensure that only a non negative number may be entered.
+     * @param {string} text The user's text.
+     * @return A string representing a valid positive number, or null if invalid.
+     */
+    doClassValidation_(text: string): number;
+    /**
+     * Return the current note frequency.
+     * @return Current note in string format.
+     */
+    getValue(): string;
+    /**
+     * Called by setValue if the text input is valid. Updates the value of the
+     * field, and updates the text of the field if it is not currently being
+     * edited (i.e. handled by the htmlInput_).
+     * @param {string} note The new note in string format.
+     */
+    doValueUpdate_(note: string): void;
+    /**
+     * Get the text from this field
+     * @return Current text.
+     */
+    getText(): string;
+    /**
+     * This block shows up differently when it's being edited;
+     * on any transition between `editing <--> not-editing`
+     * or other change in state,
+     * refresh the text to get back into a valid state.
+     **/
+    protected refreshText(): void;
+    onFinishEditing_(text: string): void;
+    protected onHide(): void;
+    /**
+     * Create a piano under the note field.
+     */
+    showEditor_(e: Event): void;
+    protected playKey(key: HTMLDivElement, frequency: number): void;
+    /**
+     * Close the note picker if this input is being deleted.
+     */
+    dispose(): void;
+    private updateColor;
+    protected setPage(page: number): void;
+    /**
+     * create a DOM to assign a style to the previous and next buttons
+     * @param pianoWidth the width of the containing piano
+     * @param isPrev true if is previous button, false otherwise
+     * @return DOM with the new css style.s
+     */
+    protected getNextPrevDiv(isPrev: boolean, pianoWidth: number): HTMLDivElement;
+    protected getKeyDiv(keyInd: number, leftPosition: number): HTMLDivElement;
+    /**
+     * @param idx index of the key
+     * @return true if idx is white
+     */
+    protected isWhite(idx: number): boolean;
+    protected whiteKeysBefore(idx: number): number;
+    /**
+     * get width of the piano key
+     * @param idx index of the key
+     * @return width of the key
+     */
+    protected getKeyWidth(idx: number): number;
+    /**
+     * get height of the piano key
+     * @param idx index of the key
+     * @return height of the key
+     */
+    protected getKeyHeight(idx: number): number;
+    protected getKeyFreq(keyIndex: number): number;
+    protected getKeyName(keyIndex: number): string;
+    private getKeyNoteData;
+    /**
+     * get the position of the key in the piano
+     * @param idx index of the key
+     * @return position of the key
+     */
+    protected getPosition(idx: number): number;
+    private prepareNotes;
+}

package/built/pxtblocks/fields/field_numberdropdown.d.ts

@@ -0,0 +1,28 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustom, FieldCustomDropdownOptions } from "./field_utils";
+import { BaseFieldTextDropdown } from "./field_textdropdown";
+declare class BaseFieldNumberDropdown extends BaseFieldTextDropdown {
+    min_: number;
+    max_: number;
+    precision_: number;
+    decimalPlaces: number;
+    constructor(value: number | string, menuGenerator: Blockly.MenuOption[], opt_min?: number, opt_max?: number, opt_precision?: number, opt_validator?: Blockly.FieldValidator);
+    setConstraints(min: number | string | undefined | null, max: number | string | undefined | null, precision: number | string | undefined | null): void;
+    getValue(): string;
+    private setMinInternal;
+    private setMaxInternal;
+    private setPrecisionInternal;
+    protected doClassValidation_(newValue?: any): string;
+}
+export interface FieldNumberDropdownOptions extends FieldCustomDropdownOptions {
+    min?: number;
+    max?: number;
+    precision?: any;
+}
+export declare class FieldNumberDropdown extends BaseFieldNumberDropdown implements FieldCustom {
+    isFieldCustom_: boolean;
+    constructor(value: number | string, options: FieldNumberDropdownOptions, opt_validator?: Blockly.FieldValidator);
+    getOptions(): [string, string][];
+}
+export {};

package/built/pxtblocks/fields/field_position.d.ts

@@ -0,0 +1,29 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldSlider } from "../plugins/math";
+import { FieldCustomOptions, FieldCustom } from "./field_utils";
+export interface FieldPositionOptions extends FieldCustomOptions {
+    min?: string;
+    max?: string;
+    screenWidth?: number;
+    screenHeight?: number;
+    xInputName?: string;
+    yInputName?: string;
+}
+export declare class FieldPosition extends FieldSlider implements FieldCustom {
+    isFieldCustom_: boolean;
+    private params;
+    private selectorDiv_;
+    private resetCrosshair;
+    constructor(text: string, params: FieldPositionOptions, validator?: Blockly.FieldValidator);
+    showEditor_(_opt_e?: Event): void;
+    doValueUpdate_(value: string): void;
+    protected renderScreenPicker(): void;
+    private resizeHandler;
+    private setXY;
+    private getFieldByName;
+    private getXY;
+    private getTargetField;
+    widgetDispose_(): void;
+    private close;
+}

package/built/pxtblocks/fields/field_procedure.d.ts

@@ -0,0 +1,12 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldDropdown } from "./field_dropdown";
+export declare class FieldProcedure extends FieldDropdown {
+    protected rawValue: string;
+    constructor(funcname: string, opt_validator?: Blockly.FieldValidator);
+    getOptions(useCache?: boolean): Blockly.MenuOption[];
+    protected doClassValidation_(newValue?: string): string;
+    protected doValueUpdate_(newValue: string): void;
+    init(): void;
+    setSourceBlock(block: Blockly.Block): void;
+}

package/built/pxtblocks/fields/field_protractor.d.ts

@@ -0,0 +1,27 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldSlider } from "../plugins/math";
+import { FieldCustomOptions, FieldCustom } from "./field_utils";
+export interface FieldProtractorOptions extends FieldCustomOptions {
+}
+export declare class FieldProtractor extends FieldSlider implements FieldCustom {
+    isFieldCustom_: boolean;
+    private params;
+    private circleSVG;
+    private circleBar;
+    private reporter;
+    /**
+     * Class for a color wheel field.
+     * @param {number|string} value The initial content of the field.
+     * @param {Function=} opt_validator An optional function that is called
+     *     to validate any constraints on what the user entered.  Takes the new
+     *     text as an argument and returns either the accepted text, a replacement
+     *     text, or null to abort the change.
+     * @extends {Blockly.FieldNumber}
+     * @constructor
+     */
+    constructor(value_: any, params: FieldProtractorOptions, opt_validator?: Blockly.FieldValidator);
+    createLabelDom_(labelText: string): [HTMLDivElement, HTMLSpanElement];
+    setReadout(value: string | number): void;
+    private updateAngle;
+}

package/built/pxtblocks/fields/field_sound_effect.d.ts

@@ -0,0 +1,37 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldBase } from "./field_base";
+import { FieldCustomOptions } from "./field_utils";
+export interface FieldSoundEffectParams extends FieldCustomOptions {
+    durationInputName: string;
+    startFrequencyInputName: string;
+    endFrequencyInputName: string;
+    startVolumeInputName: string;
+    endVolumeInputName: string;
+    waveFieldName: string;
+    interpolationFieldName: string;
+    effectFieldName: string;
+    useMixerSynthesizer: any;
+}
+export declare class FieldSoundEffect extends FieldBase<FieldSoundEffectParams> {
+    protected mostRecentValue: pxt.assets.Sound;
+    protected drawnSound: pxt.assets.Sound;
+    protected workspace: Blockly.Workspace;
+    protected registeredChangeListener: boolean;
+    protected onInit(): void;
+    protected onDispose(): void;
+    protected onValueChanged(newValue: string): string;
+    redrawPreview(): void;
+    showEditor_(): void;
+    render_(): void;
+    protected updateSiblingBlocks(sound: pxt.assets.Sound): void;
+    protected setNumberInputValue(name: string, value: number): void;
+    protected getNumberInputValue(name: string, defaultValue: number): number;
+    protected fireNumberInputUpdate(name: string, oldValue: number): void;
+    protected setFieldDropdownValue(name: string, value: string): void;
+    protected getFieldDropdownValue(name: string): string;
+    protected fireFieldDropdownUpdate(name: string, oldValue: string): void;
+    protected readCurrentSound(): pxt.assets.Sound;
+    protected readBlockDataSound(): pxt.assets.Sound;
+    protected onWorkspaceChange: (ev: Blockly.Events.BlockChange) => void;
+}

package/built/pxtblocks/fields/field_speed.d.ts

@@ -0,0 +1,32 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldSlider } from "../plugins/math";
+import { FieldCustomOptions, FieldCustom } from "./field_utils";
+export interface FieldSpeedOptions extends FieldCustomOptions {
+    min?: string;
+    max?: string;
+    format?: string;
+    label?: string;
+}
+export declare class FieldSpeed extends FieldSlider implements FieldCustom {
+    isFieldCustom_: boolean;
+    private params;
+    private speedSVG;
+    private circleBar;
+    private reporter;
+    /**
+     * Class for a color wheel field.
+     * @param {number|string} value The initial content of the field.
+     * @param {Function=} opt_validator An optional function that is called
+     *     to validate any constraints on what the user entered.  Takes the new
+     *     text as an argument and returns either the accepted text, a replacement
+     *     text, or null to abort the change.
+     * @extends {Blockly.FieldNumber}
+     * @constructor
+     */
+    constructor(value_: any, params: FieldSpeedOptions, opt_validator?: Blockly.FieldValidator);
+    createLabelDom_(labelText: string): [HTMLDivElement, HTMLSpanElement];
+    setReadout(value: string | number): void;
+    private updateSpeed;
+    private sign;
+}

package/built/pxtblocks/fields/field_sprite.d.ts

@@ -0,0 +1,26 @@
+/// <reference path="../../pxtlib.d.ts" />
+import { FieldAssetEditor } from "./field_asset";
+export interface FieldSpriteEditorOptions {
+    sizes: string;
+    initColor: string;
+    initWidth: string;
+    initHeight: string;
+    disableResize: string;
+    filter?: string;
+    lightMode: boolean;
+}
+interface ParsedSpriteEditorOptions {
+    initColor: number;
+    initWidth: number;
+    initHeight: number;
+    disableResize: boolean;
+    filter?: string;
+    lightMode: boolean;
+}
+export declare class FieldSpriteEditor extends FieldAssetEditor<FieldSpriteEditorOptions, ParsedSpriteEditorOptions> {
+    protected getAssetType(): pxt.AssetType;
+    protected createNewAsset(text?: string): pxt.Asset;
+    protected getValueText(): string;
+    protected parseFieldOptions(opts: FieldSpriteEditorOptions): ParsedSpriteEditorOptions;
+}
+export {};

package/built/pxtblocks/fields/field_styledlabel.d.ts

@@ -0,0 +1,11 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustomOptions, FieldCustom } from "./field_utils";
+export interface StyleOptions extends FieldCustomOptions {
+    bold: boolean;
+    italics: boolean;
+}
+export declare class FieldStyledLabel extends Blockly.FieldLabel implements FieldCustom {
+    isFieldCustom_: boolean;
+    constructor(value: string, options?: StyleOptions, opt_validator?: Function);
+}