pxt-core 9.3.13 → 9.3.15

package/{built → localtypings}/pxteditor.d.ts

@@ -1,1201 +1,1206 @@
-/// <reference path="../localtypings/monaco.d.ts" />
-/// <reference path="pxtlib.d.ts" />
-/// <reference path="pxtblocks.d.ts" />
+/// <reference path="../built/pxtlib.d.ts" />
+/// <reference path="../built/pxtblocks.d.ts" />
+/// <reference path="./projectheader.d.ts" />
+
 declare namespace pxt.editor {
-    enum SimState {
-        Stopped = 0,
-        Pending = 1,
-        Starting = 2,
-        Running = 3
+    export interface EditorMessage {
+        /**
+         * Constant identifier
+         */
+        type: "pxteditor" | "pxthost" | "pxtpkgext" | "pxtsim",
+        /**
+         * Original request id
+         */
+        id?: string;
+        /**
+         * flag to request response
+         */
+        response?: boolean;
     }
-    interface IEditor {
-        undo(): void;
-        redo(): void;
-        hasUndo(): boolean;
-        hasRedo(): boolean;
-        zoomIn(): void;
-        zoomOut(): void;
-        resize(): void;
-        setScale(scale: number): void;
+
+    export interface EditorMessageResponse extends EditorMessage {
+        /**
+         * Additional response payload provided by the command
+         */
+        resp?: any;
+        /**
+         * indicate if operation started or completed successfully
+         */
+        success: boolean;
+        /**
+         * Error object if any
+         */
+        error?: any;
     }
-    interface IFile {
-        name: string;
-        virtual?: boolean;
+
+    export interface EditorMessageRequest extends EditorMessage {
+        /**
+         * Request action
+         */
+        action: "switchblocks"
+        | "switchjavascript"
+        | "startsimulator"
+        | "restartsimulator"
+        | "stopsimulator" // EditorMessageStopRequest
+        | "hidesimulator"
+        | "showsimulator"
+        | "closeflyout"
+        | "newproject"
+        | "importproject"
+        | "importtutorial"
+        | "openheader"
+        | "proxytosim" // EditorMessageSimulatorMessageProxyRequest
+        | "undo"
+        | "redo"
+        | "renderblocks"
+        | "renderpython"
+        | "setscale"
+        | "startactivity"
+        | "saveproject"
+        | "unloadproject"
+        | "shareproject"
+        | "savelocalprojectstocloud"
+        | "projectcloudstatus"
+        | "requestprojectcloudstatus"
+        | "convertcloudprojectstolocal"
+        | "setlanguagerestriction"
+
+        | "toggletrace" // EditorMessageToggleTraceRequest
+        | "togglehighcontrast"
+        | "sethighcontrast" // EditorMessageSetHighContrastRequest
+        | "togglegreenscreen"
+        | "settracestate" //
+        | "setsimulatorfullscreen" // EditorMessageSimulatorFullScreenRequest
+
+        | "print" // print code
+        | "pair" // pair device
+
+        | "workspacesync" // EditorWorspaceSyncRequest
+        | "workspacereset"
+        | "workspacesave" // EditorWorkspaceSaveRequest
+        | "workspaceloaded"
+        | "workspaceevent" // EditorWorspaceEvent
+
+        | "workspacediagnostics" // compilation results
+
+        | "event"
+        | "simevent"
+        | "info" // return info data`
+        | "tutorialevent"
+        | "editorcontentloaded"
+        | "runeval"
+
+        // package extension messasges
+        | ExtInitializeType
+        | ExtDataStreamType
+        | ExtUserCodeType
+        | ExtReadCodeType
+        | ExtWriteCodeType
+        ;
+    }
+
+    /**
+     * Request sent by the editor when a tick/error/expection is registered
+     */
+    export interface EditorMessageEventRequest extends EditorMessageRequest {
+        action: "event";
+        // metric identifier
+        tick: string;
+        // error category if any
+        category?: string;
+        // error message if any
+        message?: string;
+        // custom data
+        data?: pxt.Map<string | number>;
+    }
+
+    export type EditorMessageTutorialEventRequest = EditorMessageTutorialProgressEventRequest |
+        EditorMessageTutorialCompletedEventRequest |
+        EditorMessageTutorialLoadedEventRequest |
+        EditorMessageTutorialExitEventRequest;
+
+    export interface EditorMessageTutorialProgressEventRequest extends EditorMessageRequest {
+        action: "tutorialevent";
+        tutorialEvent: "progress"
+        currentStep: number;
+        totalSteps: number;
+        isCompleted: boolean;
+        tutorialId: string;
+        projectHeaderId: string;
     }
-    function isBlocks(f: IFile): boolean;
-    interface FileHistoryEntry {
-        id: string;
-        name: string;
-        pos: any;
+
+    export interface EditorMessageTutorialCompletedEventRequest extends EditorMessageRequest {
+        action: "tutorialevent";
+        tutorialEvent: "completed";
+        tutorialId: string;
+        projectHeaderId: string;
     }
-    interface EditorSettings {
-        editorFontSize: number;
-        fileHistory: FileHistoryEntry[];
+
+    export interface EditorMessageTutorialLoadedEventRequest extends EditorMessageRequest {
+        action: "tutorialevent";
+        tutorialEvent: "loaded";
+        tutorialId: string;
+        projectHeaderId: string;
     }
-    enum ErrorListState {
-        HeaderOnly = "errorListHeader",
-        Expanded = "errorListExpanded"
+
+    export interface EditorMessageTutorialExitEventRequest extends EditorMessageRequest {
+        action: "tutorialevent";
+        tutorialEvent: "exit";
+        tutorialId: string;
+        projectHeaderId: string;
     }
-    enum MuteState {
-        Muted = "muted",
-        Unmuted = "unmuted",
-        Disabled = "disabled"
+
+    export interface EditorMessageStopRequest extends EditorMessageRequest {
+        action: "stopsimulator";
+        /**
+         * Indicates if simulator iframes should be unloaded or kept hot.
+         */
+        unload?: boolean;
     }
-    interface IAppProps {
+
+    export interface EditorMessageNewProjectRequest extends EditorMessageRequest {
+        action: "newproject";
+        /**
+         * Additional optional to create new project
+         */
+        options?: ProjectCreationOptions;
     }
-    interface IAppState {
-        active?: boolean;
-        header?: pxt.workspace.Header;
-        editorState?: EditorState;
-        currFile?: IFile;
-        fileState?: string;
-        showFiles?: boolean;
-        sideDocsLoadUrl?: string;
-        sideDocsCollapsed?: boolean;
-        projectName?: string;
-        suppressPackageWarning?: boolean;
-        tutorialOptions?: pxt.tutorial.TutorialOptions;
-        lightbox?: boolean;
-        keymap?: boolean;
-        simState?: SimState;
-        autoRun?: boolean;
-        resumeOnVisibility?: boolean;
-        compiling?: boolean;
-        isSaving?: boolean;
-        publishing?: boolean;
-        hideEditorFloats?: boolean;
-        collapseEditorTools?: boolean;
-        showBlocks?: boolean;
-        showParts?: boolean;
-        fullscreen?: boolean;
-        showMiniSim?: boolean;
-        mute?: MuteState;
-        embedSimView?: boolean;
-        editorPosition?: {
-            lineNumber: number;
-            column: number;
-            file: IFile;
-        };
-        tracing?: boolean;
-        debugging?: boolean;
-        debugFirstRun?: boolean;
-        bannerVisible?: boolean;
-        pokeUserComponent?: string;
-        flashHint?: boolean;
-        editorOffset?: string;
-        print?: boolean;
-        greenScreen?: boolean;
-        accessibleBlocks?: boolean;
-        home?: boolean;
-        hasError?: boolean;
-        cancelledDownload?: boolean;
-        simSerialActive?: boolean;
-        deviceSerialActive?: boolean;
-        errorListState?: ErrorListState;
-        screenshoting?: boolean;
-        extensionsVisible?: boolean;
-        isMultiplayerGame?: boolean;
-        onboarding?: pxt.tour.BubbleStep[];
+
+    export interface EditorContentLoadedRequest extends EditorMessageRequest {
+        action: "editorcontentloaded";
     }
-    interface EditorState {
-        filters?: pxt.editor.ProjectFilters;
+
+    export interface EditorMessageSetScaleRequest extends EditorMessageRequest {
+        action: "setscale";
+        scale: number;
+    }
+
+    export interface EditorMessageSimulatorMessageProxyRequest extends EditorMessageRequest {
+        action: "proxytosim";
+        /**
+         * Content to send to the simulator
+         */
+        content: any;
+    }
+
+    export interface EditorWorkspaceSyncRequest extends EditorMessageRequest {
+        /**
+         * Synching projects from host into
+         */
+        action: "workspacesync" | "workspacereset" | "workspaceloaded";
+    }
+
+    export interface EditorWorkspaceEvent extends EditorMessageRequest {
+        action: "workspaceevent";
+        event: EditorEvent;
+    }
+
+    export interface EditorWorkspaceDiagnostics extends EditorMessageRequest {
+        action: "workspacediagnostics";
+        operation: "compile" | "decompile" | "typecheck";
+        output: string;
+        diagnostics: {
+            code: number;
+            category: "error" | "warning" | "message";
+            fileName?: string;
+            start?: number;
+            length?: number;
+            line?: number;
+            column?: number;
+            endLine?: number;
+            endColumn?: number;
+        }[];
+    }
+
+    // UI properties to sync on load
+    export interface EditorSyncState {
+        // (optional) filtering argument
+        filters?: ProjectFilters;
+        // (optional) show or hide the search bar
         searchBar?: boolean;
-        hasCategories?: boolean;
     }
-    interface ProjectCreationOptions {
-        prj?: pxt.ProjectTemplate;
-        name?: string;
-        documentation?: string;
-        filesOverride?: pxt.Map<string>;
+
+    export interface EditorWorkspaceSyncResponse extends EditorMessageResponse {
+        /*
+        * Full list of project, required for init
+        */
+        projects: pxt.workspace.Project[];
+        // (optional) filtering argument
+        editor?: EditorSyncState;
+        // (optional) controller id, used for determining what the parent controller is
+        controllerId?: string;
+    }
+
+    export interface EditorWorkspaceSaveRequest extends EditorMessageRequest {
+        action: "workspacesave";
+        /*
+        * Modified project
+        */
+        project: pxt.workspace.Project;
+    }
+
+    export interface EditorMessageImportProjectRequest extends EditorMessageRequest {
+        action: "importproject";
+        // project to load
+        project: pxt.workspace.Project;
+        // (optional) filtering argument
         filters?: ProjectFilters;
-        temporary?: boolean;
-        tutorial?: pxt.tutorial.TutorialOptions;
-        dependencies?: pxt.Map<string>;
-        tsOnly?: boolean;
-        languageRestriction?: LanguageRestriction;
-        preferredEditor?: string;
-        extensionUnderTest?: string;
-        skillmapProject?: boolean;
-        simTheme?: Partial<pxt.PackageConfig>;
-        firstProject?: boolean;
+        searchBar?: boolean;
     }
-    interface ExampleImportOptions {
-        name: string;
-        path: string;
-        loadBlocks?: boolean;
-        prj?: ProjectTemplate;
-        preferredEditor?: string;
+
+    export interface EditorMessageSaveLocalProjectsToCloud extends EditorMessageRequest {
+        action: "savelocalprojectstocloud";
+        headerIds: string[];
     }
-    interface StartActivityOptions {
-        activity: Activity;
-        path: string;
-        title?: string;
-        editor?: string;
-        focus?: boolean;
-        importOptions?: pxt.editor.ExampleImportOptions;
-        previousProjectHeaderId?: string;
-        carryoverPreviousCode?: boolean;
+
+    export interface EditorMessageSaveLocalProjectsToCloudResponse extends EditorMessageResponse {
+        action: "savelocalprojectstocloud";
+        headerIdMap?: pxt.Map<string>;
     }
-    interface ProjectFilters {
-        namespaces?: {
-            [index: string]: FilterState;
-        };
-        blocks?: {
-            [index: string]: FilterState;
-        };
-        fns?: {
-            [index: string]: FilterState;
-        };
-        defaultState?: FilterState;
-    }
-    enum FilterState {
-        Hidden = 0,
-        Visible = 1,
-        Disabled = 2
+
+    export interface EditorMessageProjectCloudStatus extends EditorMessageRequest {
+        action: "projectcloudstatus";
+        headerId: string;
+        status: pxt.cloud.CloudStatus;
     }
-    interface ModalDialogButton {
-        label: string;
-        url?: string;
+
+    export interface EditorMessageRequestProjectCloudStatus extends EditorMessageRequest {
+        action: "requestprojectcloudstatus";
+        headerIds: string[];
     }
-    interface ModalDialogOptions {
-        header: string;
-        body: string;
-        buttons?: ModalDialogButton[];
+
+    export interface EditorMessageConvertCloudProjectsToLocal extends EditorMessageRequest {
+        action: "convertcloudprojectstolocal";
+        userId: string;
     }
-    interface ScreenshotData {
-        data?: ImageData;
-        delay?: number;
-        event?: "start" | "stop";
+
+    export interface EditorMessageImportTutorialRequest extends EditorMessageRequest {
+        action: "importtutorial";
+        // markdown to load
+        markdown: string;
     }
-    interface SimulatorStartOptions {
-        clickTrigger?: boolean;
+
+    export interface EditorMessageOpenHeaderRequest extends EditorMessageRequest {
+        action: "openheader";
+        headerId: string;
     }
-    interface ImportFileOptions {
-        extension?: boolean;
-        openHomeIfFailed?: boolean;
+
+    export interface EditorMessageRenderBlocksRequest extends EditorMessageRequest {
+        action: "renderblocks";
+        // typescript code to render
+        ts: string;
+        // rendering options
+        snippetMode?: boolean;
+        layout?: pxt.blocks.BlockLayout;
     }
-    interface UserInfo {
-        id: string;
-        userName?: string;
-        name: string;
-        profile?: string;
-        loginHint?: string;
-        initials?: string;
-        photo?: string;
+
+    export interface EditorMessageRunEvalRequest extends EditorMessageRequest {
+        action: "runeval";
+        validatorPlan: pxt.blocks.ValidatorPlan;
     }
-    interface ShareData {
-        url: string;
-        embed: {
-            code?: string;
-            editor?: string;
-            simulator?: string;
-            url?: string;
-        };
-        qr?: string;
-        error?: any;
+
+    export interface EditorMessageRenderBlocksResponse {
+        svg: SVGSVGElement;
+        xml: Promise<any>;
     }
-    type Activity = "tutorial" | "recipe" | "example";
-    interface IProjectView {
-        state: IAppState;
-        setState(st: IAppState): void;
-        forceUpdate(): void;
-        reloadEditor(): void;
-        openBlocks(): void;
-        openJavaScript(giveFocusOnLoading?: boolean): void;
-        openPython(giveFocusOnLoading?: boolean): void;
-        openAssets(): void;
-        openSettings(): void;
-        openSimView(): void;
-        openSimSerial(): void;
-        openDeviceSerial(): void;
-        openPreviousEditor(): void;
-        switchTypeScript(): void;
-        openTypeScriptAsync(): Promise<void>;
-        openPythonAsync(): Promise<void>;
-        saveBlocksToTypeScriptAsync(): Promise<string>;
-        saveFileAsync(): Promise<void>;
-        saveCurrentSourceAsync(): Promise<void>;
-        saveProjectAsync(): Promise<void>;
-        loadHeaderAsync(h: pxt.workspace.Header): Promise<void>;
-        reloadHeaderAsync(): Promise<void>;
-        importProjectAsync(prj: pxt.workspace.Project, editorState?: pxt.editor.EditorState): Promise<void>;
-        importTutorialAsync(markdown: string): Promise<void>;
-        openProjectByHeaderIdAsync(headerId: string): Promise<void>;
-        overrideTypescriptFile(text: string): void;
-        overrideBlocksFile(text: string): void;
-        resetTutorialTemplateCode(keepAssets: boolean): Promise<void>;
-        exportAsync(): Promise<string>;
-        newEmptyProject(name?: string, documentation?: string, preferredEditor?: string): void;
-        newProject(options?: ProjectCreationOptions): void;
-        createProjectAsync(options: ProjectCreationOptions): Promise<void>;
-        importExampleAsync(options: ExampleImportOptions): Promise<void>;
-        showScriptManager(): void;
-        importProjectDialog(): void;
-        removeProject(): void;
-        editText(): void;
-        hasCloudSync(): boolean;
-        getPreferredEditor(): string;
-        saveAndCompile(): void;
-        updateHeaderName(name: string): void;
-        updateHeaderNameAsync(name: string): Promise<void>;
-        compile(): void;
-        setFile(fn: IFile, line?: number): void;
-        setSideFile(fn: IFile, line?: number): void;
-        navigateToError(diag: pxtc.KsDiagnostic): void;
-        setSideDoc(path: string, blocksEditor?: boolean): void;
-        setSideMarkdown(md: string): void;
-        setSideDocCollapsed(shouldCollapse?: boolean): void;
-        removeFile(fn: IFile, skipConfirm?: boolean): void;
-        updateFileAsync(name: string, content: string, open?: boolean): Promise<void>;
-        openHome(): void;
-        unloadProjectAsync(home?: boolean): Promise<void>;
-        setTutorialStep(step: number): void;
-        setTutorialInstructionsExpanded(value: boolean): void;
-        exitTutorial(): void;
-        completeTutorialAsync(): Promise<void>;
-        showTutorialHint(): void;
-        isTutorial(): boolean;
-        onEditorContentLoaded(): void;
-        pokeUserActivity(): void;
-        stopPokeUserActivity(): void;
-        clearUserPoke(): void;
-        setHintSeen(step: number): void;
-        setEditorOffset(): void;
-        anonymousPublishHeaderByIdAsync(headerId: string, projectName?: string): Promise<ShareData>;
-        publishCurrentHeaderAsync(persistent: boolean, screenshotUri?: string): Promise<string>;
-        publishAsync(name: string, screenshotUri?: string, forceAnonymous?: boolean): Promise<pxt.editor.ShareData>;
-        startStopSimulator(opts?: SimulatorStartOptions): void;
-        stopSimulator(unload?: boolean, opts?: SimulatorStartOptions): void;
-        restartSimulator(): void;
-        startSimulator(opts?: SimulatorStartOptions): void;
-        runSimulator(): void;
-        isSimulatorRunning(): boolean;
-        expandSimulator(): void;
-        collapseSimulator(): void;
-        toggleSimulatorCollapse(): void;
-        toggleSimulatorFullscreen(): void;
-        setSimulatorFullScreen(enabled: boolean): void;
-        proxySimulatorMessage(content: string): void;
-        toggleTrace(intervalSpeed?: number): void;
-        setTrace(enabled: boolean, intervalSpeed?: number): void;
-        toggleMute(): void;
-        setMute(state: MuteState): void;
-        openInstructions(): void;
-        closeFlyout(): void;
-        printCode(): void;
-        requestScreenshotAsync(): Promise<string>;
-        downloadScreenshotAsync(): Promise<void>;
-        toggleDebugging(): void;
-        dbgPauseResume(): void;
-        dbgStepInto(): void;
-        dbgStepOver(): void;
-        dbgInsertBreakpoint(): void;
-        setBannerVisible(b: boolean): void;
-        typecheckNow(): void;
-        shouldPreserveUndoStack(): boolean;
-        openExtension(extension: string, url: string, consentRequired?: boolean, trusted?: boolean): void;
-        handleExtensionRequest(request: ExtensionRequest): void;
-        fireResize(): void;
-        updateEditorLogo(left: number, rgba?: string): number;
-        loadBlocklyAsync(): Promise<void>;
-        isBlocksEditor(): boolean;
-        isTextEditor(): boolean;
-        isPxtJsonEditor(): boolean;
-        blocksScreenshotAsync(pixelDensity?: number, encodeBlocks?: boolean): Promise<string>;
-        renderBlocksAsync(req: EditorMessageRenderBlocksRequest): Promise<EditorMessageRenderBlocksResponse>;
-        renderPythonAsync(req: EditorMessageRenderPythonRequest): Promise<EditorMessageRenderPythonResponse>;
-        toggleHighContrast(): void;
-        setHighContrast(on: boolean): void;
-        toggleGreenScreen(): void;
-        toggleAccessibleBlocks(): void;
-        setAccessibleBlocks(enabled: boolean): void;
-        launchFullEditor(): void;
-        resetWorkspace(): void;
-        settings: EditorSettings;
-        isEmbedSimActive(): boolean;
-        isBlocksActive(): boolean;
-        isJavaScriptActive(): boolean;
-        isPythonActive(): boolean;
-        isAssetsActive(): boolean;
-        editor: IEditor;
-        startActivity(options: StartActivityOptions): void;
-        showLightbox(): void;
-        hideLightbox(): void;
-        showOnboarding(): void;
-        hideOnboarding(): void;
-        showKeymap(show: boolean): void;
-        toggleKeymap(): void;
-        signOutGithub(): void;
-        showReportAbuse(): void;
-        showLanguagePicker(): void;
-        showShareDialog(title?: string, kind?: "multiplayer" | "vscode" | "share"): void;
-        showAboutDialog(): void;
-        showTurnBackTimeDialogAsync(): Promise<void>;
-        showLoginDialog(continuationHash?: string): void;
-        showProfileDialog(location?: string): void;
-        showImportUrlDialog(): void;
-        showImportFileDialog(options?: ImportFileOptions): void;
-        showImportGithubDialog(): void;
-        showResetDialog(): void;
-        showExitAndSaveDialog(): void;
-        showChooseHwDialog(skipDownload?: boolean): void;
-        showExperimentsDialog(): void;
-        showPackageDialog(query?: string): void;
-        showBoardDialogAsync(features?: string[], closeIcon?: boolean): Promise<void>;
-        checkForHwVariant(): boolean;
-        pairAsync(): Promise<boolean>;
-        createModalClasses(classes?: string): string;
-        showModalDialogAsync(options: ModalDialogOptions): Promise<void>;
-        askForProjectCreationOptionsAsync(): Promise<ProjectCreationOptions>;
-        pushScreenshotHandler(handler: (msg: ScreenshotData) => void): void;
-        popScreenshotHandler(): void;
-        openNewTab(header: pxt.workspace.Header, dependent: boolean): void;
-        createGitHubRepositoryAsync(): Promise<void>;
-        saveLocalProjectsToCloudAsync(headerIds: string[]): Promise<pxt.Map<string> | undefined>;
-        requestProjectCloudStatus(headerIds: string[]): Promise<void>;
-        convertCloudProjectsToLocal(userId: string): Promise<void>;
-        setLanguageRestrictionAsync(restriction: pxt.editor.LanguageRestriction): Promise<void>;
-        hasHeaderBeenPersistentShared(): boolean;
-        getSharePreferenceForHeader(): boolean;
-        saveSharePreferenceForHeaderAsync(anonymousByDefault: boolean): Promise<void>;
+
+    export interface EditorMessageRenderPythonRequest extends EditorMessageRequest {
+        action: "renderpython";
+        // typescript code to render
+        ts: string;
     }
-    interface IHexFileImporter {
-        id: string;
-        canImport(data: pxt.cpp.HexFile): boolean;
-        importAsync(project: IProjectView, data: pxt.cpp.HexFile): Promise<void>;
+
+    export interface EditorMessageRenderPythonResponse {
+        python: string;
     }
-    interface IResourceImporter {
-        id: string;
-        canImport(data: File): boolean;
-        importAsync(project: IProjectView, data: File): Promise<void>;
+
+    export interface EditorSimulatorEvent extends EditorMessageRequest {
+        action: "simevent";
+        subtype: "toplevelfinished" | "started" | "stopped" | "resumed"
     }
-    interface ISettingsProps {
-        parent: IProjectView;
-        visible?: boolean;
-        collapsed?: boolean;
-        simSerialActive?: boolean;
-        devSerialActive?: boolean;
+
+    export interface EditorSimulatorStoppedEvent extends EditorSimulatorEvent {
+        subtype: "stopped";
+        exception?: string;
     }
-    interface IFieldCustomOptions {
-        selector: string;
-        editor: Blockly.FieldCustomConstructor;
-        text?: string;
-        validator?: any;
+
+    export interface EditorMessageToggleTraceRequest extends EditorMessageRequest {
+        action: "toggletrace";
+        // interval speed for the execution trace
+        intervalSpeed?: number;
     }
-    interface ExtensionOptions {
-        blocklyToolbox: ToolboxDefinition;
-        monacoToolbox: ToolboxDefinition;
-        projectView: IProjectView;
+
+    export interface EditorMessageSetTraceStateRequest extends EditorMessageRequest {
+        action: "settracestate";
+        enabled: boolean;
+        // interval speed for the execution trace
+        intervalSpeed?: number;
     }
-    interface IToolboxOptions {
-        blocklyToolbox?: ToolboxDefinition;
-        monacoToolbox?: ToolboxDefinition;
+
+    export interface EditorMessageSetSimulatorFullScreenRequest extends EditorMessageRequest {
+        action: "setsimulatorfullscreen";
+        enabled: boolean;
     }
-    interface ExtensionResult {
-        hexFileImporters?: IHexFileImporter[];
-        resourceImporters?: IResourceImporter[];
-        beforeCompile?: () => void;
-        patchCompileResultAsync?: (r: pxtc.CompileResult) => Promise<void>;
-        deployAsync?: (r: pxtc.CompileResult) => Promise<void>;
-        saveOnlyAsync?: (r: ts.pxtc.CompileResult) => Promise<void>;
-        saveProjectAsync?: (project: pxt.cpp.HexFile) => Promise<void>;
-        renderBrowserDownloadInstructions?: () => any;
-        renderUsbPairDialog?: (firmwareUrl?: string, failedOnce?: boolean) => any;
-        renderIncompatibleHardwareDialog?: (unsupportedParts: string[]) => any;
-        showUploadInstructionsAsync?: (fn: string, url: string, confirmAsync: (options: any) => Promise<number>) => Promise<void>;
-        showProgramTooLargeErrorAsync?: (variants: string[], confirmAsync: (options: any) => Promise<number>) => Promise<pxt.commands.RecompileOptions>;
-        toolboxOptions?: IToolboxOptions;
-        blocklyPatch?: (pkgTargetVersion: string, dom: Element) => void;
-        webUsbPairDialogAsync?: (pairAsync: () => Promise<boolean>, confirmAsync: (options: any) => Promise<number>) => Promise<number>;
-        mkPacketIOWrapper?: (io: pxt.packetio.PacketIO) => pxt.packetio.PacketIOWrapper;
-        onTutorialCompleted?: () => void;
-        onCodeStart?: () => void;
-        onCodeStop?: () => void;
+
+    export interface EditorMessageSetHighContrastRequest extends EditorMessageRequest {
+        action: "sethighcontrast";
+        on: boolean;
     }
-    interface FieldExtensionOptions {
+
+    export interface EditorMessageStartActivity extends EditorMessageRequest {
+        action: "startactivity";
+        activityType: "tutorial" | "example" | "recipe";
+        path: string;
+        title?: string;
+        previousProjectHeaderId?: string;
+        carryoverPreviousCode?: boolean;
     }
-    interface FieldExtensionResult {
-        fieldEditors?: IFieldCustomOptions[];
+
+    export interface InfoMessage {
+        versions: pxt.TargetVersions;
+        locale: string;
+        availableLocales?: string[];
     }
-    interface ToolboxDefinition {
-        loops?: ToolboxCategoryDefinition;
-        logic?: ToolboxCategoryDefinition;
-        variables?: ToolboxCategoryDefinition;
-        maths?: ToolboxCategoryDefinition;
-        text?: ToolboxCategoryDefinition;
-        arrays?: ToolboxCategoryDefinition;
-        functions?: ToolboxCategoryDefinition;
+
+    export interface PackageExtensionData {
+        ts: string;
+        json?: any;
     }
-    interface ToolboxCategoryDefinition {
-        /**
-         * The display name for the category
-         */
-        name?: string;
-        /**
-         * The icon of this category
-         */
-        icon?: string;
-        /**
-         * The color of this category
-         */
-        color?: string;
-        /**
-         * The weight of the category relative to other categories in the toolbox
-         */
-        weight?: number;
-        /**
-         * Whether or not the category should be placed in the advanced category
-         */
-        advanced?: boolean;
-        /**
-         * Blocks to appear in the category. Specifying this field will override
-         * all existing blocks in the category. The ordering of the blocks is
-         * determined by the ordering of this array.
-         */
-        blocks?: ToolboxBlockDefinition[];
-        /**
-         * Ordering of category groups
-         */
-        groups?: string[];
+
+    export interface EditorPkgExtMessageRequest extends EditorMessageRequest {
+        // extension identifier
+        package: string;
     }
-    interface ToolboxBlockDefinition {
-        /**
-         * Internal id used to refer to this block or snippet, must be unique
-         */
-        name: string;
-        /**
-         * Group label used to categorize block.  Blocks are arranged with other
-         * blocks that share the same group.
-         */
-        group?: string;
-        /**
-         * Indicates an advanced API. Advanced APIs appear after basic ones in the
-         * toolbox
-         */
-        advanced?: boolean;
-        /**
-         * The weight for the block. Blocks are arranged in order of they appear in the category
-         * definition's array but the weight can be specified in the case that other APIs are
-         * dynamically added to the category (eg. loops.forever())
-         */
-        weight?: number;
-        /**
-         * Description of code to appear in the hover text
-         */
-        jsDoc?: string;
-        /**
-         * TypeScript snippet of code to insert when dragged into editor
-         */
-        snippet?: string;
-        /**
-         * Python snippet of code to insert when dragged into editor
-         */
-        pySnippet?: string;
-        /**
-         * TypeScript name used for highlighting the snippet, uses name if not defined
-         */
-        snippetName?: string;
-        /**
-         * Python name used for highlighting the snippet, uses name if not defined
-         */
-        pySnippetName?: string;
-        /**
-         * Display just the snippet and nothing else. Should be set to true for
-         * language constructs (eg. for-loops) and to false for function
-         * calls (eg. Math.random())
-         */
-        snippetOnly?: boolean;
-        /**
-         * The return type of the block. This is used to determine the shape of the block rendered.
-         */
-        retType?: string;
-        /**
-         * The block definition in XML for the blockly toolbox.
-         */
-        blockXml?: string;
-        /**
-         * The Blockly block id used to identify this block.
-         */
-        blockId?: string;
+
+    export interface EditorPkgExtMessageResponse extends EditorMessageResponse {
+        // extension identifier
+        package: string;
     }
-    let initExtensionsAsync: (opts: ExtensionOptions) => Promise<ExtensionResult>;
-    let initFieldExtensionsAsync: (opts: FieldExtensionOptions) => Promise<FieldExtensionResult>;
-    interface NativeHostMessage {
-        name?: string;
-        download?: string;
-        save?: string;
-        cmd?: string;
+
+    export interface EditorSimulatorTickEvent extends EditorMessageEventRequest {
+        type: "pxtsim";
+    }
+
+    export interface EditorShareRequest extends EditorMessageRequest {
+        action: "shareproject";
+        headerId: string;
+        projectName: string;
+    }
+
+    export interface EditorShareResponse extends EditorMessageRequest {
+        action: "shareproject";
+        script: pxt.Cloud.JsonScript;
+    }
+
+    export interface EditorSetLanguageRestriction extends EditorMessageRequest {
+        action: "setlanguagerestriction";
+        restriction: pxt.editor.LanguageRestriction;
+    }
+
+    export interface DataStreams<T> {
+        console?: T;
+        messages?: T;
+    }
+
+    export interface ExtensionFiles {
+        code?: string;
+        json?: string;
+        jres?: string;
+        asm?: string;
+    }
+
+    export interface WriteExtensionFiles extends ExtensionFiles {
+        dependencies?: pxt.Map<string>;
     }
-    let HELP_IMAGE_URI: string;
-    function initEditorExtensionsAsync(): Promise<void>;
-}
-declare namespace pxt.editor {
-    interface EditorMessage {
-        /**
-         * Constant identifier
-         */
-        type: "pxteditor" | "pxthost" | "pxtpkgext" | "pxtsim";
-        /**
-         * Original request id
-         */
-        id?: string;
-        /**
-         * flag to request response
-         */
-        response?: boolean;
+
+    export interface ExtensionMessage extends EditorMessage {
+        type: "pxtpkgext";
     }
-    interface EditorMessageResponse extends EditorMessage {
-        /**
-         * Additional response payload provided by the command
-         */
-        resp?: any;
-        /**
-         * indicate if operation started or completed successfully
-         */
-        success: boolean;
-        /**
-         * Error object if any
-         */
-        error?: any;
+
+    export interface ExtensionResponse extends EditorMessageResponse {
+        type: "pxtpkgext";
+        extId: string;
     }
-    interface EditorMessageRequest extends EditorMessage {
-        /**
-         * Request action
-         */
-        action: "switchblocks" | "switchjavascript" | "startsimulator" | "restartsimulator" | "stopsimulator" | "hidesimulator" | "showsimulator" | "closeflyout" | "newproject" | "importproject" | "importtutorial" | "openheader" | "proxytosim" | "undo" | "redo" | "renderblocks" | "renderpython" | "setscale" | "startactivity" | "saveproject" | "unloadproject" | "shareproject" | "savelocalprojectstocloud" | "projectcloudstatus" | "requestprojectcloudstatus" | "convertcloudprojectstolocal" | "setlanguagerestriction" | "toggletrace" | "togglehighcontrast" | "sethighcontrast" | "togglegreenscreen" | "settracestate" | "setsimulatorfullscreen" | "print" | "pair" | "workspacesync" | "workspacereset" | "workspacesave" | "workspaceloaded" | "workspaceevent" | "workspacediagnostics" | "event" | "simevent" | "info" | "tutorialevent" | "editorcontentloaded" | ExtInitializeType | ExtDataStreamType | ExtUserCodeType | ExtReadCodeType | ExtWriteCodeType;
+
+    export interface ExtensionRequest extends EditorMessageRequest {
+        type: "pxtpkgext";
+        extId: string;
+        body?: any;
     }
+
     /**
-     * Request sent by the editor when a tick/error/expection is registered
+     * Events are fired by the editor on the extension iFrame. Extensions
+     * receive events, they don't send them.
      */
-    interface EditorMessageEventRequest extends EditorMessageRequest {
-        action: "event";
-        tick: string;
-        category?: string;
-        message?: string;
-        data?: Map<string | number>;
-    }
-    type EditorMessageTutorialEventRequest = EditorMessageTutorialProgressEventRequest | EditorMessageTutorialCompletedEventRequest | EditorMessageTutorialLoadedEventRequest | EditorMessageTutorialExitEventRequest;
-    interface EditorMessageTutorialProgressEventRequest extends EditorMessageRequest {
-        action: "tutorialevent";
-        tutorialEvent: "progress";
-        currentStep: number;
-        totalSteps: number;
-        isCompleted: boolean;
-        tutorialId: string;
-        projectHeaderId: string;
+    export interface ExtensionEvent extends ExtensionMessage {
+        event: string;
+        target: string;
     }
-    interface EditorMessageTutorialCompletedEventRequest extends EditorMessageRequest {
-        action: "tutorialevent";
-        tutorialEvent: "completed";
-        tutorialId: string;
-        projectHeaderId: string;
+
+    /**
+     * Event fired when the extension is loaded.
+     */
+    export interface LoadedEvent extends ExtensionEvent {
+        event: "extloaded";
     }
-    interface EditorMessageTutorialLoadedEventRequest extends EditorMessageRequest {
-        action: "tutorialevent";
-        tutorialEvent: "loaded";
-        tutorialId: string;
-        projectHeaderId: string;
+
+    /**
+     * Event fired when the extension becomes visible.
+     */
+    export interface ShownEvent extends ExtensionEvent {
+        event: "extshown";
     }
-    interface EditorMessageTutorialExitEventRequest extends EditorMessageRequest {
-        action: "tutorialevent";
-        tutorialEvent: "exit";
-        tutorialId: string;
-        projectHeaderId: string;
+
+    /**
+     * Event fired when the extension becomes hidden.
+     */
+    export interface HiddenEvent extends ExtensionEvent {
+        event: "exthidden";
+        body: HiddenReason;
     }
-    interface EditorMessageStopRequest extends EditorMessageRequest {
-        action: "stopsimulator";
-        /**
-         * Indicates if simulator iframes should be unloaded or kept hot.
-         */
-        unload?: boolean;
+
+    export type HiddenReason = "useraction" | "other";
+
+    /**
+     * Event fired when console data is received
+     */
+    export interface ConsoleEvent extends ExtensionEvent {
+        event: "extconsole";
+        body: {
+            source: string;
+            sim: boolean;
+            data: string;
+        }
     }
-    interface EditorMessageNewProjectRequest extends EditorMessageRequest {
-        action: "newproject";
-        /**
-         * Additional optional to create new project
-         */
-        options?: ProjectCreationOptions;
+
+    /**
+     * Event fired when a message packet is received
+     */
+    export interface MessagePacketEvent extends ExtensionEvent {
+        event: "extmessagepacket";
+        body: {
+            source?: string;
+            channel: string;
+            data: Uint8Array;
+        }
     }
-    interface EditorContentLoadedRequest extends EditorMessageRequest {
-        action: "editorcontentloaded";
+
+    /**
+     * Event fired when extension is first shown. Extension
+     * should send init request in response
+     */
+    export type ExtInitializeType = "extinit";
+
+    export interface InitializeRequest extends ExtensionRequest {
+        action: ExtInitializeType;
+        body: string;
     }
-    interface EditorMessageSetScaleRequest extends EditorMessageRequest {
-        action: "setscale";
-        scale: number;
+
+    export interface InitializeResponse extends ExtensionResponse {
+        target?: pxt.AppTarget;
     }
-    interface EditorMessageSimulatorMessageProxyRequest extends EditorMessageRequest {
-        action: "proxytosim";
-        /**
-         * Content to send to the simulator
-         */
-        content: any;
+
+    /**
+     * Requests data stream event to be fired. Permission will
+     * be requested if not already received.
+     */
+    export type ExtDataStreamType = "extdatastream";
+
+    export interface DataStreamRequest extends ExtensionRequest {
+        action: ExtDataStreamType;
+        body: DataStreams<boolean>;
     }
-    interface EditorWorkspaceSyncRequest extends EditorMessageRequest {
-        /**
-         * Synching projects from host into
-         */
-        action: "workspacesync" | "workspacereset" | "workspaceloaded";
+
+    export interface DataStreamResponse extends ExtensionResponse {
+        resp: DataStreams<boolean>;
     }
-    interface EditorWorkspaceEvent extends EditorMessageRequest {
-        action: "workspaceevent";
-        event: pxt.editor.events.Event;
+
+    /**
+     * Request to read the user's code. Will request permission if
+     * not already granted
+     */
+    export type ExtUserCodeType = "extusercode";
+
+    export interface UserCodeRequest extends ExtensionRequest {
+        action: ExtUserCodeType;
     }
-    interface EditorWorkspaceDiagnostics extends EditorMessageRequest {
-        action: "workspacediagnostics";
-        operation: "compile" | "decompile" | "typecheck";
-        output: string;
-        diagnostics: {
-            code: number;
-            category: "error" | "warning" | "message";
-            fileName?: string;
-            start?: number;
-            length?: number;
-            line?: number;
-            column?: number;
-            endLine?: number;
-            endColumn?: number;
-        }[];
+
+    export interface UserCodeResponse extends ExtensionResponse {
+        /* A mapping of file names to their contents */
+        resp?: { [index: string]: string };
     }
-    interface EditorSyncState {
-        filters?: pxt.editor.ProjectFilters;
-        searchBar?: boolean;
+
+    /**
+     * Request to read the files saved by this extension
+     */
+    export type ExtReadCodeType = "extreadcode";
+
+    export interface ReadCodeRequest extends ExtensionRequest {
+        action: ExtReadCodeType;
     }
-    interface EditorWorkspaceSyncResponse extends EditorMessageResponse {
-        projects: pxt.workspace.Project[];
-        editor?: EditorSyncState;
-        controllerId?: string;
+
+    export interface ReadCodeResponse extends ExtensionResponse {
+        action: ExtReadCodeType;
+
+        body?: ExtensionFiles;
     }
-    interface EditorWorkspaceSaveRequest extends EditorMessageRequest {
-        action: "workspacesave";
-        project: pxt.workspace.Project;
+
+    /**
+     * Request to write the JSON and/or TS files saved
+     * by this extension
+     */
+    export type ExtWriteCodeType = "extwritecode";
+
+    export interface WriteCodeRequest extends ExtensionRequest {
+        action: ExtWriteCodeType;
+
+        body?: WriteExtensionFiles;
     }
-    interface EditorMessageImportProjectRequest extends EditorMessageRequest {
-        action: "importproject";
-        project: pxt.workspace.Project;
-        filters?: pxt.editor.ProjectFilters;
-        searchBar?: boolean;
+
+    export interface WriteCodeResponse extends ExtensionResponse {
     }
-    interface EditorMessageSaveLocalProjectsToCloud extends EditorMessageRequest {
-        action: "savelocalprojectstocloud";
-        headerIds: string[];
+
+    export interface ProjectCreationOptions {
+        prj?: pxt.ProjectTemplate;
+        name?: string;
+        documentation?: string;
+        filesOverride?: pxt.Map<string>;
+        filters?: ProjectFilters;
+        temporary?: boolean;
+        tutorial?: pxt.tutorial.TutorialOptions;
+        dependencies?: pxt.Map<string>;
+        tsOnly?: boolean; // DEPRECATED: use LanguageRestriction.NoBlocks or LanguageRestriction.JavaScriptOnly instead
+        languageRestriction?: pxt.editor.LanguageRestriction;
+        preferredEditor?: string; // preferred editor to open, pxt.BLOCKS_PROJECT_NAME, ...
+        extensionUnderTest?: string; // workspace id of the extension under test
+        skillmapProject?: boolean;
+        simTheme?: Partial<pxt.PackageConfig>;
+        firstProject?: boolean;
     }
-    interface EditorMessageSaveLocalProjectsToCloudResponse extends EditorMessageResponse {
-        action: "savelocalprojectstocloud";
-        headerIdMap?: pxt.Map<string>;
+
+    export interface ProjectFilters {
+        namespaces?: { [index: string]: FilterState; }; // Disabled = 2, Hidden = 0, Visible = 1
+        blocks?: { [index: string]: FilterState; }; // Disabled = 2, Hidden = 0, Visible = 1
+        fns?: { [index: string]: FilterState; }; // Disabled = 2, Hidden = 0, Visible = 1
+        defaultState?: FilterState; // hide, show or disable all by default
     }
-    interface EditorMessageProjectCloudStatus extends EditorMessageRequest {
-        action: "projectcloudstatus";
-        headerId: string;
-        status: pxt.cloud.CloudStatus;
+
+    export const enum FilterState {
+        Hidden = 0,
+        Visible = 1,
+        Disabled = 2
     }
-    interface EditorMessageRequestProjectCloudStatus extends EditorMessageRequest {
-        action: "requestprojectcloudstatus";
-        headerIds: string[];
+
+    export type EditorType = 'blocks' | 'ts';
+
+    export interface EditorEvent {
+        type: string;
+        editor: EditorType;
     }
-    interface EditorMessageConvertCloudProjectsToLocal extends EditorMessageRequest {
-        action: "convertcloudprojectstolocal";
-        userId: string;
+
+    export interface CreateEvent extends EditorEvent {
+        type: "create";
+        blockId: string;
     }
-    interface EditorMessageImportTutorialRequest extends EditorMessageRequest {
-        action: "importtutorial";
-        markdown: string;
+
+    export interface UIEvent extends EditorEvent {
+        type: "ui";
+        action: "groupHelpClicked";
+        data?: pxt.Map<string>;
     }
-    interface EditorMessageOpenHeaderRequest extends EditorMessageRequest {
-        action: "openheader";
-        headerId: string;
+
+    export interface IEditor {
+        undo(): void;
+        redo(): void;
+        hasUndo(): boolean;
+        hasRedo(): boolean;
+        zoomIn(): void;
+        zoomOut(): void;
+        resize(): void;
+        setScale(scale: number): void;
     }
-    interface EditorMessageRenderBlocksRequest extends EditorMessageRequest {
-        action: "renderblocks";
-        ts: string;
-        snippetMode?: boolean;
-        layout?: pxt.blocks.BlockLayout;
+
+    export interface IFile {
+        name: string;
+        virtual?: boolean; // gimmick to switch views
     }
-    interface EditorMessageRenderBlocksResponse {
-        svg: SVGSVGElement;
-        xml: Promise<any>;
+
+    export interface FileHistoryEntry {
+        id: string;
+        name: string;
+        pos: any;
     }
-    interface EditorMessageRenderPythonRequest extends EditorMessageRequest {
-        action: "renderpython";
-        ts: string;
+
+    export interface EditorSettings {
+        editorFontSize: number;
+        fileHistory: FileHistoryEntry[];
     }
-    interface EditorMessageRenderPythonResponse {
-        python: string;
+
+    export const enum ErrorListState {
+        HeaderOnly = "errorListHeader",
+        Expanded = "errorListExpanded"
     }
-    interface EditorSimulatorEvent extends EditorMessageRequest {
-        action: "simevent";
-        subtype: "toplevelfinished" | "started" | "stopped" | "resumed";
+
+    export const enum MuteState {
+        Muted = "muted",
+        Unmuted = "unmuted",
+        Disabled = "disabled"
     }
-    interface EditorSimulatorStoppedEvent extends EditorSimulatorEvent {
-        subtype: "stopped";
-        exception?: string;
+
+    export const enum SimState {
+        Stopped,
+        // waiting to be started
+        Pending,
+        Starting,
+        Running
     }
-    interface EditorMessageToggleTraceRequest extends EditorMessageRequest {
-        action: "toggletrace";
-        intervalSpeed?: number;
+
+    export interface NativeHostMessage {
+        name?: string;
+        download?: string;
+        save?: string;
+        cmd?: string;
     }
-    interface EditorMessageSetTraceStateRequest extends EditorMessageRequest {
-        action: "settracestate";
-        enabled: boolean;
-        intervalSpeed?: number;
+
+    export interface IAppProps { }
+    export interface IAppState {
+        active?: boolean; // is this tab visible at all
+        header?: pxt.workspace.Header;
+        editorState?: EditorState;
+        currFile?: IFile;
+        fileState?: string;
+        showFiles?: boolean;
+        sideDocsLoadUrl?: string; // set once to load the side docs frame
+        sideDocsCollapsed?: boolean;
+        projectName?: string;
+        suppressPackageWarning?: boolean;
+        tutorialOptions?: pxt.tutorial.TutorialOptions;
+        lightbox?: boolean;
+        keymap?: boolean;
+        simState?: SimState;
+        autoRun?: boolean;
+        resumeOnVisibility?: boolean;
+        compiling?: boolean;
+        isSaving?: boolean;
+        publishing?: boolean;
+        hideEditorFloats?: boolean;
+        collapseEditorTools?: boolean;
+        showBlocks?: boolean;
+        showParts?: boolean;
+        fullscreen?: boolean;
+        showMiniSim?: boolean;
+        mute?: MuteState;
+        embedSimView?: boolean;
+        editorPosition?: {
+            lineNumber: number;
+            column: number;
+            file: IFile;
+        }; // ensure that this line is visible when loading the editor
+        tracing?: boolean;
+        debugging?: boolean;
+        debugFirstRun?: boolean;
+        bannerVisible?: boolean;
+        pokeUserComponent?: string;
+        flashHint?: boolean;
+        editorOffset?: string;
+        print?: boolean;
+        greenScreen?: boolean;
+        accessibleBlocks?: boolean;
+        home?: boolean;
+        hasError?: boolean;
+        cancelledDownload?: boolean;
+        simSerialActive?: boolean;
+        deviceSerialActive?: boolean;
+        errorListState?: ErrorListState;
+        screenshoting?: boolean;
+        extensionsVisible?: boolean;
+        isMultiplayerGame?: boolean; // Arcade: Does the current project contain multiplayer blocks?
+        onboarding?: pxt.tour.BubbleStep[];
     }
-    interface EditorMessageSetSimulatorFullScreenRequest extends EditorMessageRequest {
-        action: "setsimulatorfullscreen";
-        enabled: boolean;
+
+    export interface EditorState {
+        filters?: pxt.editor.ProjectFilters;
+        searchBar?: boolean; // show the search bar in editor
+        hasCategories?: boolean; // show categories in toolbox
     }
-    interface EditorMessageSetHighContrastRequest extends EditorMessageRequest {
-        action: "sethighcontrast";
-        on: boolean;
+
+    export interface ExampleImportOptions {
+        name: string;
+        path: string;
+        loadBlocks?: boolean;
+        prj?: pxt.ProjectTemplate;
+        preferredEditor?: string;
     }
-    interface EditorMessageStartActivity extends EditorMessageRequest {
-        action: "startactivity";
-        activityType: "tutorial" | "example" | "recipe";
+
+    export interface StartActivityOptions {
+        activity: Activity;
         path: string;
         title?: string;
+        editor?: string;
+        focus?: boolean;
+        importOptions?: ExampleImportOptions;
         previousProjectHeaderId?: string;
         carryoverPreviousCode?: boolean;
     }
-    interface InfoMessage {
-        versions: pxt.TargetVersions;
-        locale: string;
-        availableLocales?: string[];
-    }
-    interface PackageExtensionData {
-        ts: string;
-        json?: any;
-    }
-    interface EditorPkgExtMessageRequest extends EditorMessageRequest {
-        package: string;
-    }
-    interface EditorPkgExtMessageResponse extends EditorMessageResponse {
-        package: string;
+
+    export interface ModalDialogButton {
+        label: string;
+        url?: string;
     }
-    interface EditorSimulatorTickEvent extends EditorMessageEventRequest {
-        type: "pxtsim";
+
+    export interface ModalDialogOptions {
+        header: string;
+        body: string;
+        buttons?: ModalDialogButton[];
     }
-    interface EditorShareRequest extends EditorMessageRequest {
-        action: "shareproject";
-        headerId: string;
-        projectName: string;
+
+    export interface ScreenshotData {
+        data?: ImageData;
+        delay?: number;
+        event?: "start" | "stop";
     }
-    interface EditorShareResponse extends EditorMessageRequest {
-        action: "shareproject";
-        script: Cloud.JsonScript;
+
+    export interface SimulatorStartOptions {
+        clickTrigger?: boolean;
     }
-    interface EditorSetLanguageRestriction extends EditorMessageRequest {
-        action: "setlanguagerestriction";
-        restriction: pxt.editor.LanguageRestriction;
+
+    export interface ImportFileOptions {
+        extension?: boolean;
+        openHomeIfFailed?: boolean;
     }
-    /**
-     * Binds incoming window messages to the project view.
-     * Requires the "allowParentController" flag in the pxtarget.json/appTheme object.
-     *
-     * When the project view receives a request (EditorMessageRequest),
-     * it starts the command and returns the result upon completion.
-     * The response (EditorMessageResponse) contains the request id and result.
-     * Some commands may be async, use the ``id`` field to correlate to the original request.
-     */
-    function bindEditorMessages(getEditorAsync: () => Promise<IProjectView>): void;
-    /**
-     * Sends analytics messages upstream to container if any
-     */
-    function enableControllerAnalytics(): void;
-    /**
-     * Determines if host messages should be posted
-     */
-    function shouldPostHostMessages(): boolean;
-    /**
-     * Posts a message from the editor to the host
-     */
-    function postHostMessageAsync(msg: EditorMessageRequest): Promise<EditorMessageResponse>;
-}
-declare namespace pxt.editor.events {
-    type EditorType = 'blocks' | 'ts';
-    interface Event {
-        type: string;
-        editor: EditorType;
+
+    export interface UserInfo {
+        id: string;
+        userName?: string;
+        name: string;
+        profile?: string;
+        loginHint?: string;
+        initials?: string;
+        photo?: string;
     }
-    interface CreateEvent extends Event {
-        type: "create";
-        blockId: string;
+
+    export interface ShareData {
+        url: string;
+        embed: {
+            code?: string;
+            editor?: string;
+            simulator?: string;
+            url?: string;
+        }
+        qr?: string;
+        error?: any;
     }
-    interface UIEvent extends Event {
-        type: "ui";
-        action: "groupHelpClicked";
-        data?: pxt.Map<string>;
+
+    export type Activity = "tutorial" | "recipe" | "example";
+
+    export interface IProjectView {
+        state: IAppState;
+        setState(st: IAppState): void;
+        forceUpdate(): void;
+
+        reloadEditor(): void;
+        openBlocks(): void;
+        openJavaScript(giveFocusOnLoading?: boolean): void;
+        openPython(giveFocusOnLoading?: boolean): void;
+        openAssets(): void;
+        openSettings(): void;
+        openSimView(): void;
+        openSimSerial(): void;
+        openDeviceSerial(): void;
+        openPreviousEditor(): void;
+
+        switchTypeScript(): void;
+        openTypeScriptAsync(): Promise<void>;
+        openPythonAsync(): Promise<void>;
+        saveBlocksToTypeScriptAsync(): Promise<string>;
+
+        saveFileAsync(): Promise<void>;
+        saveCurrentSourceAsync(): Promise<void>;
+        saveProjectAsync(): Promise<void>;
+        loadHeaderAsync(h: pxt.workspace.Header): Promise<void>;
+        reloadHeaderAsync(): Promise<void>;
+        importProjectAsync(prj: pxt.workspace.Project, editorState?: EditorState): Promise<void>;
+        importTutorialAsync(markdown: string): Promise<void>;
+        openProjectByHeaderIdAsync(headerId: string): Promise<void>;
+        overrideTypescriptFile(text: string): void;
+        overrideBlocksFile(text: string): void;
+        resetTutorialTemplateCode(keepAssets: boolean): Promise<void>;
+
+        exportAsync(): Promise<string>;
+
+        newEmptyProject(name?: string, documentation?: string, preferredEditor?: string): void;
+        newProject(options?: pxt.editor.ProjectCreationOptions): void;
+        createProjectAsync(options: pxt.editor.ProjectCreationOptions): Promise<void>;
+        importExampleAsync(options: ExampleImportOptions): Promise<void>;
+        showScriptManager(): void;
+        importProjectDialog(): void;
+        removeProject(): void;
+        editText(): void;
+
+        hasCloudSync(): boolean;
+
+        getPreferredEditor(): string;
+        saveAndCompile(): void;
+        updateHeaderName(name: string): void;
+        updateHeaderNameAsync(name: string): Promise<void>;
+        compile(): void;
+
+        setFile(fn: IFile, line?: number): void;
+        setSideFile(fn: IFile, line?: number): void;
+        navigateToError(diag: pxtc.KsDiagnostic): void;
+        setSideDoc(path: string, blocksEditor?: boolean): void;
+        setSideMarkdown(md: string): void;
+        setSideDocCollapsed(shouldCollapse?: boolean): void;
+        removeFile(fn: IFile, skipConfirm?: boolean): void;
+        updateFileAsync(name: string, content: string, open?: boolean): Promise<void>;
+
+        openHome(): void;
+        unloadProjectAsync(home?: boolean): Promise<void>;
+        setTutorialStep(step: number): void;
+        setTutorialInstructionsExpanded(value: boolean): void;
+        exitTutorial(): void;
+        completeTutorialAsync(): Promise<void>;
+        showTutorialHint(): void;
+        isTutorial(): boolean;
+        onEditorContentLoaded(): void;
+        pokeUserActivity(): void;
+        stopPokeUserActivity(): void;
+        clearUserPoke(): void;
+        setHintSeen(step: number): void;
+        setEditorOffset(): void;
+
+        anonymousPublishHeaderByIdAsync(headerId: string, projectName?: string): Promise<ShareData>;
+        publishCurrentHeaderAsync(persistent: boolean, screenshotUri?: string): Promise<string>;
+        publishAsync (name: string, screenshotUri?: string, forceAnonymous?: boolean): Promise<ShareData>;
+
+        startStopSimulator(opts?: SimulatorStartOptions): void;
+        stopSimulator(unload?: boolean, opts?: SimulatorStartOptions): void;
+        restartSimulator(): void;
+        startSimulator(opts?: SimulatorStartOptions): void;
+        runSimulator(): void;
+        isSimulatorRunning(): boolean;
+        expandSimulator(): void;
+        collapseSimulator(): void;
+        toggleSimulatorCollapse(): void;
+        toggleSimulatorFullscreen(): void;
+        setSimulatorFullScreen(enabled: boolean): void;
+        proxySimulatorMessage(content: string): void;
+        toggleTrace(intervalSpeed?: number): void;
+        setTrace(enabled: boolean, intervalSpeed?: number): void;
+        toggleMute(): void;
+        setMute(state: MuteState): void;
+        openInstructions(): void;
+        closeFlyout(): void;
+        printCode(): void;
+        requestScreenshotAsync(): Promise<string>;
+        downloadScreenshotAsync(): Promise<void>;
+
+        toggleDebugging(): void;
+        dbgPauseResume(): void;
+        dbgStepInto(): void;
+        dbgStepOver(): void;
+        dbgInsertBreakpoint(): void;
+
+        setBannerVisible(b: boolean): void;
+        typecheckNow(): void;
+        shouldPreserveUndoStack(): boolean;
+
+        openExtension(extension: string, url: string, consentRequired?: boolean, trusted?: boolean): void;
+        handleExtensionRequest(request: pxt.editor.ExtensionRequest): void;
+
+        fireResize(): void;
+        updateEditorLogo(left: number, rgba?: string): number;
+
+        loadBlocklyAsync(): Promise<void>;
+        isBlocksEditor(): boolean;
+        isTextEditor(): boolean;
+        isPxtJsonEditor(): boolean;
+        blocksScreenshotAsync(pixelDensity?: number, encodeBlocks?: boolean): Promise<string>;
+        renderBlocksAsync(req: pxt.editor.EditorMessageRenderBlocksRequest): Promise<pxt.editor.EditorMessageRenderBlocksResponse>;
+        renderPythonAsync(req: pxt.editor.EditorMessageRenderPythonRequest): Promise<pxt.editor.EditorMessageRenderPythonResponse>;
+        getBlocks(): Blockly.Block[];
+
+        toggleHighContrast(): void;
+        setHighContrast(on: boolean): void;
+        toggleGreenScreen(): void;
+        toggleAccessibleBlocks(): void;
+        setAccessibleBlocks(enabled: boolean): void;
+        launchFullEditor(): void;
+        resetWorkspace(): void;
+
+        settings: EditorSettings;
+
+        isEmbedSimActive(): boolean;
+        isBlocksActive(): boolean;
+        isJavaScriptActive(): boolean;
+        isPythonActive(): boolean;
+        isAssetsActive(): boolean;
+
+        editor: IEditor;
+
+        startActivity(options: StartActivityOptions): void;
+        showLightbox(): void;
+        hideLightbox(): void;
+        showOnboarding(): void;
+        hideOnboarding(): void;
+        showKeymap(show: boolean): void;
+        toggleKeymap(): void;
+        signOutGithub(): void;
+
+        showReportAbuse(): void;
+        showLanguagePicker(): void;
+        showShareDialog(title?: string, kind?: "multiplayer" | "vscode" | "share"): void;
+        showAboutDialog(): void;
+        showTurnBackTimeDialogAsync(): Promise<void>;
+
+        showLoginDialog(continuationHash?: string): void;
+        showProfileDialog(location?: string): void;
+
+        showImportUrlDialog(): void;
+        showImportFileDialog(options?: ImportFileOptions): void;
+        showImportGithubDialog(): void;
+
+        showResetDialog(): void;
+        showExitAndSaveDialog(): void;
+        showChooseHwDialog(skipDownload?: boolean): void;
+        showExperimentsDialog(): void;
+
+        showPackageDialog(query?: string): void;
+        showBoardDialogAsync(features?: string[], closeIcon?: boolean): Promise<void>;
+        checkForHwVariant(): boolean;
+        pairAsync(): Promise<boolean>;
+
+        createModalClasses(classes?: string): string;
+        showModalDialogAsync(options: ModalDialogOptions): Promise<void>;
+
+        askForProjectCreationOptionsAsync(): Promise<pxt.editor.ProjectCreationOptions>;
+
+        pushScreenshotHandler(handler: (msg: ScreenshotData) => void): void;
+        popScreenshotHandler(): void;
+
+        openNewTab(header: pxt.workspace.Header, dependent: boolean): void;
+        createGitHubRepositoryAsync(): Promise<void>;
+        saveLocalProjectsToCloudAsync(headerIds: string[]): Promise<pxt.Map<string> | undefined>;
+        requestProjectCloudStatus(headerIds: string[]): Promise<void>;
+        convertCloudProjectsToLocal(userId: string): Promise<void>;
+        setLanguageRestrictionAsync(restriction: pxt.editor.LanguageRestriction): Promise<void>;
+        hasHeaderBeenPersistentShared(): boolean;
+        getSharePreferenceForHeader(): boolean;
+        saveSharePreferenceForHeaderAsync(anonymousByDefault: boolean): Promise<void>;
     }
-}
-declare namespace pxt.editor.experiments {
-    interface Experiment {
+
+    export interface IHexFileImporter {
         id: string;
-        name: string;
-        description: string;
-        feedbackUrl?: string;
-        enableOnline?: boolean;
-    }
-    function syncTheme(): AppTheme;
-    function all(): Experiment[];
-    function clear(): void;
-    function someEnabled(): boolean;
-    function isEnabled(experiment: Experiment | string): boolean;
-    function toggle(experiment: Experiment): void;
-    function state(): string;
-    function setState(experiment: Experiment, enabled: boolean): void;
-}
-declare namespace pxt.editor {
-    interface DataStreams<T> {
-        console?: T;
-        messages?: T;
-    }
-    interface ExtensionFiles {
-        code?: string;
-        json?: string;
-        jres?: string;
-        asm?: string;
-    }
-    interface WriteExtensionFiles extends ExtensionFiles {
-        dependencies?: pxt.Map<string>;
-    }
-    interface ExtensionMessage extends EditorMessage {
-        type: "pxtpkgext";
-    }
-    interface ExtensionResponse extends EditorMessageResponse {
-        type: "pxtpkgext";
-        extId: string;
-    }
-    interface ExtensionRequest extends EditorMessageRequest {
-        type: "pxtpkgext";
-        extId: string;
-        body?: any;
-    }
-    /**
-     * Events are fired by the editor on the extension iFrame. Extensions
-     * receive events, they don't send them.
-     */
-    interface ExtensionEvent extends ExtensionMessage {
-        event: string;
-        target: string;
-    }
-    /**
-     * Event fired when the extension is loaded.
-     */
-    interface LoadedEvent extends ExtensionEvent {
-        event: "extloaded";
-    }
-    /**
-     * Event fired when the extension becomes visible.
-     */
-    interface ShownEvent extends ExtensionEvent {
-        event: "extshown";
-    }
-    /**
-     * Event fired when the extension becomes hidden.
-     */
-    interface HiddenEvent extends ExtensionEvent {
-        event: "exthidden";
-        body: HiddenReason;
-    }
-    type HiddenReason = "useraction" | "other";
-    /**
-     * Event fired when console data is received
-     */
-    interface ConsoleEvent extends ExtensionEvent {
-        event: "extconsole";
-        body: {
-            source: string;
-            sim: boolean;
-            data: string;
-        };
-    }
-    /**
-     * Event fired when a message packet is received
-     */
-    interface MessagePacketEvent extends ExtensionEvent {
-        event: "extmessagepacket";
-        body: {
-            source?: string;
-            channel: string;
-            data: Uint8Array;
-        };
-    }
-    /**
-     * Event fired when extension is first shown. Extension
-     * should send init request in response
-     */
-    type ExtInitializeType = "extinit";
-    interface InitializeRequest extends ExtensionRequest {
-        action: ExtInitializeType;
-        body: string;
+        canImport(data: pxt.cpp.HexFile): boolean;
+        importAsync(project: IProjectView, data: pxt.cpp.HexFile): Promise<void>;
     }
-    interface InitializeResponse extends ExtensionResponse {
-        target?: pxt.AppTarget;
+
+    export interface IResourceImporter {
+        id: string;
+        canImport(data: File): boolean;
+        importAsync(project: IProjectView, data: File): Promise<void>;
     }
-    /**
-     * Requests data stream event to be fired. Permission will
-     * be requested if not already received.
-     */
-    type ExtDataStreamType = "extdatastream";
-    interface DataStreamRequest extends ExtensionRequest {
-        action: ExtDataStreamType;
-        body: DataStreams<boolean>;
+
+    export interface ISettingsProps {
+        parent: IProjectView;
+        visible?: boolean;
+        collapsed?: boolean;
+        simSerialActive?: boolean;
+        devSerialActive?: boolean;
     }
-    interface DataStreamResponse extends ExtensionResponse {
-        resp: DataStreams<boolean>;
+
+    export interface IFieldCustomOptions {
+        selector: string;
+        editor: Blockly.FieldCustomConstructor;
+        text?: string;
+        validator?: any;
     }
-    /**
-     * Request to read the user's code. Will request permission if
-     * not already granted
-     */
-    type ExtUserCodeType = "extusercode";
-    interface UserCodeRequest extends ExtensionRequest {
-        action: ExtUserCodeType;
+
+
+    export interface ExtensionOptions {
+        blocklyToolbox: ToolboxDefinition;
+        monacoToolbox: ToolboxDefinition;
+        projectView: IProjectView;
     }
-    interface UserCodeResponse extends ExtensionResponse {
-        resp?: {
-            [index: string]: string;
-        };
+
+    export interface IToolboxOptions {
+        blocklyToolbox?: ToolboxDefinition;
+        monacoToolbox?: ToolboxDefinition;
     }
-    /**
-     * Request to read the files saved by this extension
-     */
-    type ExtReadCodeType = "extreadcode";
-    interface ReadCodeRequest extends ExtensionRequest {
-        action: ExtReadCodeType;
+
+    export interface ExtensionResult {
+        hexFileImporters?: IHexFileImporter[];
+        resourceImporters?: IResourceImporter[];
+        beforeCompile?: () => void;
+        patchCompileResultAsync?: (r: pxtc.CompileResult) => Promise<void>;
+        deployAsync?: (r: pxtc.CompileResult) => Promise<void>;
+        saveOnlyAsync?: (r: ts.pxtc.CompileResult) => Promise<void>;
+        saveProjectAsync?: (project: pxt.cpp.HexFile) => Promise<void>;
+        renderBrowserDownloadInstructions?: () => any /* JSX.Element */;
+        renderUsbPairDialog?: (firmwareUrl?: string, failedOnce?: boolean) => any /* JSX.Element */;
+        renderIncompatibleHardwareDialog?: (unsupportedParts: string[]) => any /* JSX.Element */;
+        showUploadInstructionsAsync?: (fn: string, url: string, confirmAsync: (options: any) => Promise<number>) => Promise<void>;
+        showProgramTooLargeErrorAsync?: (variants: string[], confirmAsync: (options: any) => Promise<number>) => Promise<pxt.commands.RecompileOptions>;
+        toolboxOptions?: IToolboxOptions;
+        blocklyPatch?: (pkgTargetVersion: string, dom: Element) => void;
+        webUsbPairDialogAsync?: (pairAsync: () => Promise<boolean>, confirmAsync: (options: any) => Promise<number>) => Promise<number>;
+        mkPacketIOWrapper?: (io: pxt.packetio.PacketIO) => pxt.packetio.PacketIOWrapper;
+
+        // Used with the @tutorialCompleted macro. See docs/writing-docs/tutorials.md for more info
+        onTutorialCompleted?: () => void;
+
+        // Used with @codeStart, @codeStop metadata (MINECRAFT HOC ONLY)
+        onCodeStart?: () => void;
+        onCodeStop?: () => void;
     }
-    interface ReadCodeResponse extends ExtensionResponse {
-        action: ExtReadCodeType;
-        body?: ExtensionFiles;
+
+    export interface FieldExtensionOptions {
     }
-    /**
-     * Request to write the JSON and/or TS files saved
-     * by this extension
-     */
-    type ExtWriteCodeType = "extwritecode";
-    interface WriteCodeRequest extends ExtensionRequest {
-        action: ExtWriteCodeType;
-        body?: WriteExtensionFiles;
+
+    export interface FieldExtensionResult {
+        fieldEditors?: IFieldCustomOptions[];
     }
-    interface WriteCodeResponse extends ExtensionResponse {
+
+    export interface ToolboxDefinition {
+        loops?: ToolboxCategoryDefinition;
+        logic?: ToolboxCategoryDefinition;
+        variables?: ToolboxCategoryDefinition;
+        maths?: ToolboxCategoryDefinition;
+        text?: ToolboxCategoryDefinition;
+        arrays?: ToolboxCategoryDefinition;
+        functions?: ToolboxCategoryDefinition;
     }
-}
-declare namespace pxt.workspace {
-    interface HistoryFile {
-        entries: HistoryEntry[];
-        snapshots: SnapshotEntry[];
-        shares: ShareEntry[];
-    }
-    interface HistoryEntry {
-        timestamp: number;
-        editorVersion: string;
-        changes: FileChange[];
-    }
-    interface SnapshotEntry {
-        timestamp: number;
-        editorVersion: string;
-        text: ScriptText;
-    }
-    interface ShareEntry {
-        timestamp: number;
-        id: string;
+
+    export interface ToolboxCategoryDefinition {
+        /**
+         * The display name for the category
+         */
+        name?: string;
+
+        /**
+         * The icon of this category
+         */
+        icon?: string;
+
+        /**
+         * The color of this category
+         */
+        color?: string;
+
+        /**
+         * The weight of the category relative to other categories in the toolbox
+         */
+        weight?: number;
+
+        /**
+         * Whether or not the category should be placed in the advanced category
+         */
+        advanced?: boolean;
+
+        /**
+         * Blocks to appear in the category. Specifying this field will override
+         * all existing blocks in the category. The ordering of the blocks is
+         * determined by the ordering of this array.
+         */
+        blocks?: ToolboxBlockDefinition[];
+
+        /**
+         * Ordering of category groups
+         */
+        groups?: string[],
     }
-    type FileChange = FileAddedChange | FileRemovedChange | FileEditedChange;
-    interface FileAddedChange {
-        type: "added";
-        filename: string;
-        value: string;
-    }
-    interface FileRemovedChange {
-        type: "removed";
-        filename: string;
-        value: string;
-    }
-    interface FileEditedChange {
-        type: "edited";
-        filename: string;
-        patch: any;
-    }
-    interface CollapseHistoryOptions {
-        interval: number;
-        minTime?: number;
-        maxTime?: number;
-    }
-    function collapseHistory(history: HistoryEntry[], text: ScriptText, options: CollapseHistoryOptions, diff: (a: string, b: string) => unknown, patch: (p: unknown, text: string) => string): HistoryEntry[];
-    function diffScriptText(oldVersion: pxt.workspace.ScriptText, newVersion: pxt.workspace.ScriptText, time: number, diff: (a: string, b: string) => unknown): pxt.workspace.HistoryEntry;
-    function applyDiff(text: ScriptText, history: pxt.workspace.HistoryEntry, patch: (p: unknown, text: string) => string): {
-        [x: string]: string;
-    };
-    function createSnapshot(text: ScriptText): ScriptText;
-    function applySnapshot(text: ScriptText, snapshot: ScriptText): ScriptText;
-    function parseHistoryFile(text: string): HistoryFile;
-    function updateHistory(previousText: ScriptText, toWrite: ScriptText, currentTime: number, shares: PublishVersion[], diff: (a: string, b: string) => unknown, patch: (p: unknown, text: string) => string): void;
-    function pushSnapshotOnHistory(text: ScriptText, currentTime: number): void;
-    function updateShareHistory(text: ScriptText, currentTime: number, shares: PublishVersion[]): void;
-}
-declare namespace pxt.vs {
-    interface BlockDefiniton {
-        commentAttr: pxtc.CommentAttrs;
-        fns?: Map<string>;
-    }
-    interface MethodDef {
-        sig: string;
-        snippet: string;
-        comment?: string;
-        metaData?: pxtc.CommentAttrs;
+
+    export interface ToolboxBlockDefinition {
+        /**
+         * Internal id used to refer to this block or snippet, must be unique
+         */
+        name: string;
+
+        /**
+         * Group label used to categorize block.  Blocks are arranged with other
+         * blocks that share the same group.
+         */
+        group?: string,
+
+        /**
+         * Indicates an advanced API. Advanced APIs appear after basic ones in the
+         * toolbox
+         */
+        advanced?: boolean;
+
+        /**
+         * The weight for the block. Blocks are arranged in order of they appear in the category
+         * definition's array but the weight can be specified in the case that other APIs are
+         * dynamically added to the category (eg. loops.forever())
+         */
+        weight?: number;
+
+        /**
+         * Description of code to appear in the hover text
+         */
+        jsDoc?: string
+
+        /**
+         * TypeScript snippet of code to insert when dragged into editor
+         */
+        snippet?: string;
+
+        /**
+         * Python snippet of code to insert when dragged into editor
+         */
+        pySnippet?: string;
+
+        /**
+         * TypeScript name used for highlighting the snippet, uses name if not defined
+         */
+        snippetName?: string;
+
+        /**
+         * Python name used for highlighting the snippet, uses name if not defined
+         */
+        pySnippetName?: string;
+
+        /**
+         * Display just the snippet and nothing else. Should be set to true for
+         * language constructs (eg. for-loops) and to false for function
+         * calls (eg. Math.random())
+         */
         snippetOnly?: boolean;
+
+        /**
+         * The return type of the block. This is used to determine the shape of the block rendered.
+         */
+        retType?: string;
+
+        /**
+         * The block definition in XML for the blockly toolbox.
+         */
+        blockXml?: string;
+
+        /**
+         * The Blockly block id used to identify this block.
+         */
+        blockId?: string;
     }
-    interface NameDefiniton {
-        fns: {
-            [fn: string]: MethodDef;
-        };
-        vars?: {
-            [index: string]: string;
-        };
-        metaData?: pxtc.CommentAttrs;
-        builtin?: boolean;
-    }
-    type DefinitionMap = {
-        [ns: string]: NameDefiniton;
-    };
-    function syncModels(mainPkg: MainPackage, libs: {
-        [path: string]: monaco.IDisposable;
-    }, currFile: string, readOnly: boolean): void;
-    function initMonacoAsync(element: HTMLElement): Promise<monaco.editor.IStandaloneCodeEditor>;
-    function createEditor(element: HTMLElement): monaco.editor.IStandaloneCodeEditor;
 }
+
 declare namespace pxt.workspace {
-    type ScriptText = pxt.Map<string>;
-    interface Project {
-        header?: Header;
-        text?: ScriptText;
-    }
-    interface Asset {
-        name: string;
-        size: number;
-        url: string;
-    }
-    type Version = any;
-    interface File {
-        header: Header;
-        text: ScriptText;
-        version: Version;
-    }
-    interface WorkspaceProvider {
-        listAsync(): Promise<Header[]>;
-        getAsync(h: Header): Promise<File>;
-        setAsync(h: Header, prevVersion: Version, text?: ScriptText): Promise<Version>;
-        deleteAsync?: (h: Header, prevVersion: Version) => Promise<void>;
+    export interface WorkspaceProvider {
+        listAsync(): Promise<pxt.workspace.Header[]>; // called from workspace.syncAsync (including upon startup)
+        getAsync(h: pxt.workspace.Header): Promise<File>;
+        setAsync(h: pxt.workspace.Header, prevVersion: pxt.workspace.Version, text?: pxt.workspace.ScriptText): Promise<pxt.workspace.Version>;
+        deleteAsync?: (h: pxt.workspace.Header, prevVersion: pxt.workspace.Version) => Promise<void>;
         resetAsync(): Promise<void>;
         loadedAsync?: () => Promise<void>;
         getSyncState?: () => pxt.editor.EditorSyncState;
-        saveScreenshotAsync?: (h: Header, screenshot: string, icon: string) => Promise<void>;
+
+        // optional screenshot support
+        saveScreenshotAsync?: (h: pxt.workspace.Header, screenshot: string, icon: string) => Promise<void>;
+
+        // optional asset (large binary file) support
         saveAssetAsync?: (id: string, filename: string, data: Uint8Array) => Promise<void>;
         listAssetsAsync?: (id: string) => Promise<Asset[]>;
-        fireEvent?: (ev: pxt.editor.events.Event) => void;
+
+        fireEvent?: (ev: pxt.editor.EditorEvent) => void;
     }
-    function freshHeader(name: string, modTime: number): Header;
-}
-declare namespace pxt.editor {
-    interface TextEdit {
-        range: monaco.Range;
-        replacement: string;
-    }
-    interface MonacoFieldEditorHost {
-        contentDiv(): HTMLDivElement;
-        getText(range: monaco.Range): string;
-        blocksInfo(): pxtc.BlocksInfo;
-        package(): pxt.MainPackage;
-        writeFileAsync(filename: string, content: string): Promise<void>;
-        readFile(filename: string): string;
-    }
-    interface MonacoFieldEditor {
-        getId(): string;
-        showEditorAsync(fileType: FileType, editrange: monaco.Range, host: MonacoFieldEditorHost): Promise<TextEdit>;
-        onClosed(): void;
-        dispose(): void;
-    }
-    interface MonacoFieldEditorDefinition {
-        id: string;
-        matcher: MonacoFindArguments;
-        foldMatches?: boolean;
-        alwaysBuildOnClose?: boolean;
-        glyphCssClass?: string;
-        weight?: number;
-        proto: {
-            new (): MonacoFieldEditor;
-        };
-        heightInPixels?: number;
-    }
-    interface MonacoFindArguments {
-        searchString: string;
-        isRegex: boolean;
-        matchWholeWord: boolean;
-        matchCase: boolean;
-        validateRange?: (range: monaco.Range, model: monaco.editor.ITextModel) => monaco.Range;
-    }
-    function registerMonacoFieldEditor(name: string, definition: MonacoFieldEditorDefinition): void;
-    function getMonacoFieldEditor(name: string): MonacoFieldEditorDefinition;
-}
-declare namespace pxt.editor {
-    class MonacoReactFieldEditor<U> implements MonacoFieldEditor {
-        private resolver;
-        private rejecter;
-        protected fileType: pxt.editor.FileType;
-        protected editrange: monaco.Range;
-        protected host: MonacoFieldEditorHost;
-        protected fv: pxt.react.FieldEditorView<U>;
-        getId(): string;
-        showEditorAsync(fileType: FileType, editrange: monaco.Range, host: MonacoFieldEditorHost): Promise<TextEdit>;
-        onClosed(): void;
-        dispose(): void;
-        protected initAsync(): Promise<void>;
-        protected textToValue(text: string): U;
-        protected resultToText(result: U): string;
-        protected getFieldEditorId(): string;
-        protected getOptions(): any;
-    }
-}
-declare namespace pxt.editor {
-    class MonacoSongEditor extends MonacoReactFieldEditor<pxt.Song> {
-        protected isPython: boolean;
-        protected isAsset: boolean;
-        protected text: string;
-        protected textToValue(text: string): pxt.Song;
-        protected resultToText(result: pxt.Song): string;
-        protected getFieldEditorId(): string;
-        protected getOptions(): any;
-    }
-    const songEditorDefinition: MonacoFieldEditorDefinition;
-}
-declare namespace pxt.editor {
-    class MonacoSoundEffectEditor extends MonacoReactFieldEditor<pxt.assets.Sound> {
-        protected value: pxt.assets.Sound;
-        protected textToValue(text: string): pxt.assets.Sound;
-        protected resultToText(result: pxt.assets.Sound): string;
-        protected getFieldEditorId(): string;
-        protected getOptions(): any;
-    }
-    const soundEditorDefinition: MonacoFieldEditorDefinition;
-}
-declare namespace pxt.editor {
-    class MonacoSpriteEditor extends MonacoReactFieldEditor<pxt.ProjectImage> {
-        protected isPython: boolean;
-        protected isAsset: boolean;
-        protected textToValue(text: string): pxt.ProjectImage;
-        protected resultToText(result: pxt.ProjectImage): string;
-        protected getFieldEditorId(): string;
-        protected getOptions(): any;
-    }
-    const spriteEditorDefinition: MonacoFieldEditorDefinition;
-}
-declare namespace pxt.editor {
-    class MonacoTilemapEditor extends MonacoReactFieldEditor<pxt.ProjectTilemap> {
-        protected isTilemapLiteral: boolean;
-        protected tilemapLiteral: string;
-        protected textToValue(text: string): pxt.ProjectTilemap;
-        protected readTilemap(text: string): pxt.ProjectTilemap;
-        protected resultToText(asset: pxt.ProjectTilemap): string;
-        protected getFieldEditorId(): string;
-        protected getOptions(): any;
-        protected getCreateTilemapRange(): monaco.Range;
-    }
-    const tilemapEditorDefinition: MonacoFieldEditorDefinition;
-}
+}