pxt-core/built/pxtlib.d.ts

Microsoft MakeCode provides Blocks / JavaScript / Python tools and editors

/// <reference path="../localtypings/pxtpackage.d.ts" />
/// <reference path="../localtypings/pxtparts.d.ts" />
/// <reference path="../localtypings/pxtarget.d.ts" />
/// <reference path="../localtypings/projectheader.d.ts" />
/// <reference path="../localtypings/dom.d.ts" />
/// <reference path="../localtypings/dompurify.d.ts" />
/// <reference path="../localtypings/pxtmusic.d.ts" />
/// <reference path="../pxtcompiler/ext-typescript/lib/typescriptServices.d.ts" />
/// <reference types="web-bluetooth" />
declare namespace pxt {
    function aiTrackEvent(id: string, data?: any, measures?: any): void;
    function aiTrackException(err: any, kind: string, props: any): void;
    function setInteractiveConsent(enabled: boolean): void;
}
declare namespace pxt.analytics {
    enum ConsoleTickOptions {
        Off = 0,
        Short = 1,
        Verbose = 2
    }
    let consoleTicks: ConsoleTickOptions;
    function addDefaultProperties(props: Map<string | number>): void;
    function enable(lang: string): void;
    function trackPerformanceReport(): void;
}
declare namespace pxt {
    let appTarget: TargetBundle;
    let appTargetVariant: string;
    let hwVariant: string;
    let hwName: string;
}
declare namespace pxt.AudioContextManager {
    function mute(mute: boolean): void;
    function stop(): void;
    function frequency(): number;
    function tone(frequency: number): void;
}
declare namespace pxt.auth {
    type ApiResult<T> = {
        resp: T;
        statusCode: number;
        success: boolean;
        err: any;
    };
    type UserProfile = {
        id?: string;
        idp?: {
            provider?: pxt.IdentityProviderId;
            username?: string;
            displayName?: string;
            picture?: {
                mimeType?: string;
                width?: number;
                height?: number;
                encoded?: string;
                dataUrl?: string;
            };
            pictureUrl?: string;
        };
    };
    type UserSkillmapState = {
        mapProgress: any;
        completedTags: any;
    };
    type UserBadgeState = {
        badges: Badge[];
    };
    /**
     * Mapping of target id to preferred color theme id.
     */
    type ColorThemeIdsState = {
        [targetId: string]: string;
    };
    type SetPrefResult = {
        success: boolean;
        res: UserPreferences;
    };
    /**
     * User preference state that should be synced with the cloud.
     */
    type UserPreferences = {
        language?: string;
        highContrast?: boolean;
        accessibleBlocks?: boolean;
        colorThemeIds?: ColorThemeIdsState;
        reader?: string;
        skillmap?: UserSkillmapState;
        badges?: UserBadgeState;
        email?: boolean;
    };
    const DEFAULT_USER_PREFERENCES: () => UserPreferences;
    /**
     * Cloud-synced user state.
     */
    type UserState = {
        profile?: UserProfile;
        preferences?: UserPreferences;
    };
    function client(): AuthClient;
    let cachedHasAuthToken: boolean;
    function getAuthTokenAsync(): Promise<string>;
    function hasAuthTokenAsync(): Promise<boolean>;
    let cachedUserState: Readonly<UserState>;
    function getUserStateAsync(): Promise<Readonly<UserState>>;
    function getAuthHeadersAsync(authToken?: string): Promise<pxt.Map<string>>;
    abstract class AuthClient {
        constructor();
        initAsync(): Promise<void>;
        protected abstract onSignedIn(): Promise<void>;
        protected abstract onSignedOut(): Promise<void>;
        protected abstract onSignInFailed(): Promise<void>;
        protected abstract onUserProfileChanged(): Promise<void>;
        protected abstract onUserPreferencesChanged(diff: ts.pxtc.jsonPatch.PatchOperation[]): Promise<void>;
        protected abstract onProfileDeleted(userId: string): Promise<void>;
        protected abstract onApiError(err: any): Promise<void>;
        protected abstract onStateCleared(): Promise<void>;
        /**
         * Starts the process of authenticating the user against the given identity
         * provider. Upon success the backend will write an http-only session cookie
         * to the response, containing the authorization token. This cookie is not
         * accessible in code, but will be included in all subsequent http requests.
         * @param idp The id of the identity provider.
         * @param persistent Whether or not to remember this login across sessions.
         * @param callbackState The URL hash and params to return to after the auth
         *  flow completes.
         */
        loginAsync(idp: pxt.IdentityProviderId, persistent: boolean, callbackState?: CallbackState): Promise<void>;
        /**
         * Sign out the user and clear the auth token cookie.
         */
        logoutAsync(continuationHash?: string): Promise<void>;
        /**
         * Sign out the user and clear the auth token cookie.
         */
        static staticLogoutAsync(continuationHash?: string): Promise<void>;
        deleteProfileAsync(): Promise<void>;
        private initialUserPreferences_;
        initialUserPreferencesAsync(): Promise<UserPreferences | undefined>;
        userProfileAsync(): Promise<UserProfile | undefined>;
        userPreferencesAsync(): Promise<UserPreferences | undefined>;
        private initialAuthCheck_;
        /**
         * Checks to see if we're already logged in by trying to fetch user info from
         * the backend. If we have a valid auth token cookie, it will succeed.
         */
        authCheckAsync(): Promise<UserProfile | undefined>;
        loggedInAsync(): Promise<boolean>;
        updateUserProfileAsync(opts: {
            username?: string;
            avatarUrl?: string;
        }): Promise<boolean>;
        private patchQueue;
        patchUserPreferencesAsync(patchOps: ts.pxtc.jsonPatch.PatchOperation | ts.pxtc.jsonPatch.PatchOperation[], opts?: {
            immediate?: boolean;
            filter?: (op: ts.pxtc.jsonPatch.PatchOperation) => boolean;
        }): Promise<SetPrefResult>;
        private hasUserIdAsync;
        private fetchUserAsync;
        private setUserProfileAsync;
        private setUserPreferencesAsync;
        private fetchUserPreferencesAsync;
        /**
         * Updates user profile state and writes it to local storage.
         */
        private transformUserProfileAsync;
        /**
         * Updates user preference state and writes it to local storage.
         */
        protected transformUserPreferencesAsync(preferences: UserPreferences): Promise<UserPreferences>;
        /**
         * Clear local auth state then call the onStateCleared callback.
         */
        private clearAuthStateAsync;
        apiAsync<T = any>(url: string, data?: any, method?: string, authToken?: string): Promise<ApiResult<T>>;
        static staticApiAsync<T = any>(url: string, data?: any, method?: string, authToken?: string): Promise<ApiResult<T>>;
    }
    type CallbackState = {
        hash?: string;
        params?: pxt.Map<string>;
    };
    function loginCallbackAsync(qs: pxt.Map<string>): Promise<void>;
    function identityProviders(): pxt.AppCloudProvider[];
    function identityProvider(id: pxt.IdentityProviderId): pxt.AppCloudProvider;
    function hasIdentity(): boolean;
    function enableAuth(enabled?: boolean): void;
    function userName(user: pxt.auth.UserProfile): string;
    function identityProviderId(user: pxt.auth.UserProfile): pxt.IdentityProviderId | undefined;
    function firstName(user: pxt.auth.UserProfile): string;
    function userInitials(user: pxt.auth.UserProfile): string;
    function generateUserProfilePicDataUrl(profile: pxt.auth.UserProfile): void;
    /**
     * Checks only the ID and sourceURL
     */
    function badgeEquals(badgeA: pxt.auth.Badge, badgeB: pxt.auth.Badge): boolean;
    function hasBadge(preferences: pxt.auth.UserBadgeState, badge: pxt.auth.Badge): boolean;
}
declare namespace pxt {
    interface TelemetryEventOptions {
        interactiveConsent: boolean;
    }
    /**
     * Track an event.
     */
    let tickEvent: (id: string, data?: Map<string | number>, opts?: TelemetryEventOptions) => void;
}
declare namespace pxt {
    interface Logger {
        info(...args: any[]): void;
        log(...args: any[]): void;
        debug(...args: any[]): void;
        error(...args: any[]): void;
        warn(...args: any[]): void;
        setLogLevel(level: LogLevel): void;
        getLogLevel(): LogLevel;
    }
    enum LogLevel {
        Debug = 0,
        Info = 1,
        Log = 1,
        Warning = 2,
        Error = 3
    }
    class ConsoleLogger implements Logger {
        protected logLevel: LogLevel;
        constructor();
        setLogLevel(level: LogLevel): void;
        getLogLevel(): LogLevel;
        info(...args: any[]): void;
        log(...args: any[]): void;
        debug(...args: any[]): void;
        error(...args: any[]): void;
        warn(...args: any[]): void;
        protected shouldLog(level: LogLevel): boolean;
    }
    function info(...args: any[]): void;
    function log(...args: any[]): void;
    function debug(...args: any[]): void;
    function error(...args: any[]): void;
    function warn(...args: any[]): void;
    function setLogger(impl: Logger): void;
    function setLogLevel(level: LogLevel): void;
}
declare namespace ts.pxtc {
    let __dummy: number;
}
import pxtc = ts.pxtc;
declare namespace ts.pxtc.Util {
    function assert(cond: boolean, msg?: string): void;
    function flatClone<T extends Object>(obj: T): T;
    function clone<T>(v: T): T;
    function htmlEscape(_input: string): string;
    function htmlUnescape(_input: string): string;
    function jsStringQuote(s: string): string;
    function jsStringLiteral(s: string): string;
    function initials(username: string): string;
    function enableLiveLocalizationUpdates(): void;
    function liveLocalizationEnabled(): boolean;
    /**
     * Returns the current user language, prepended by "live-" if in live mode
     */
    function localeInfo(): string;
    /**
     * Returns current user language iSO-code. Default is `en`.
     */
    function userLanguage(): string;
    function normalizeLanguageCode(code: string): string[];
    function setUserLanguage(localizeLang: string): void;
    function isUserLanguageRtl(): boolean;
    const TRANSLATION_LOCALE = "pxt";
    function isTranslationMode(): boolean;
    function _localize(s: string): string;
    function getLocalizedStrings(): pxt.Map<string>;
    function setLocalizedStrings(strs: pxt.Map<string>): void;
    function translationsCache(): pxt.Map<pxt.Map<string>>;
    function fmt_va(f: string, args: any[]): string;
    function fmt(f: string, ...args: any[]): string;
    function dumpLocStats(): void;
    function lf_va(format: string, args: any[]): string;
    function lf(format: string, ...args: any[]): string;
    /**
     * Similar to lf but the string do not get extracted into the loc file.
     */
    function rlf(format: string, ...args: any[]): string;
    /**
     * Same as lf except the strings are not replaced in translation mode. This is used
     * exclusively for blockly JSON block definitions as the crowdin in-context translation
     * script doesn't handle the SVG text fields. Instead, they are translated via a context
     * menu item on the block.
     */
    function blf(format: string): string;
    function lookup<T>(m: pxt.Map<T>, key: string): T;
    function isoTime(time: number): string;
    function userError(msg: string): never;
    function deq(a: any, b: any): string;
    function deepEqual(a: any, b: any): boolean;
}
declare const lf: typeof pxtc.U.lf;
declare namespace ts.pxtc {
    /**
     * atob replacement
     * @param s
     */
    let decodeBase64: (s: string) => string;
    /**
     * bota replacement
     * @param s
     */
    let encodeBase64: (s: string) => string;
}
declare namespace ts.pxtc.Util {
    export class CancellationToken {
        private pending;
        private cancelled;
        private resolve;
        private deferred;
        private progressHandler;
        startOperation(): void;
        isRunning(): boolean;
        onProgress(progressHandler: (completed: number, total: number) => void): void;
        reportProgress(completed: number, total: number): void;
        cancel(): void;
        cancelAsync(): Promise<void>;
        isCancelled(): boolean;
        throwIfCancelled(): void;
        resolveCancel(): void;
    }
    export function codalHash16(s: string): number;
    export function bufferSerial(buffers: pxt.Map<string>, data?: string, source?: string, maxBufLen?: number): void;
    export function blobReadAsDataURL(blob: Blob): Promise<string>;
    export function fileReadAsBufferAsync(f: File): Promise<Uint8Array>;
    export function fileReadAsTextAsync(f: File): Promise<string>;
    export function sanitizeFileName(name: string): string;
    export function repeatMap<T>(n: number, fn: (index: number) => T): T[];
    export function listsEqual<T>(a: T[], b: T[]): boolean;
    export function oops(msg?: string): Error;
    export function reversed<T>(arr: T[]): T[];
    export function arrayEquals<U>(a: U[], b: U[], compare?: (c: U, d: U) => boolean): boolean;
    export function iterMap<T>(m: pxt.Map<T>, f: (k: string, v: T) => void): void;
    export function mapMap<T, S>(m: pxt.Map<T>, f: (k: string, v: T) => S): pxt.Map<S>;
    export function values<T>(m: pxt.Map<T>): T[];
    export function pushRange<T>(trg: T[], src: ArrayLike<T>): void;
    export function concatArrayLike<T>(arrays: ArrayLike<ArrayLike<T>>): T[];
    export function concat<T>(arrays: T[][]): T[];
    export function memcpy(trg: Uint8Array, trgOff: number, src: ArrayLike<number>, srcOff?: number, len?: number): void;
    export function uint8ArrayConcat(chunks: Uint8Array[]): Uint8Array;
    export function jsonTryParse(s: string): any;
    export function jsonMergeFrom(trg: any, src: any): void;
    export function jsonCopyFrom<T>(trg: T, src: T): void;
    export function jsonFlatten(v: any): pxt.Map<any>;
    export function jsonUnFlatten(v: pxt.Map<any>): any;
    export function strcmp(a: string, b: string): 0 | 1 | -1;
    export function stringMapEq(a: pxt.Map<string>, b: pxt.Map<string>): boolean;
    export function endsWith(str: string, suffix: string): boolean;
    export function startsWith(str: string, prefix: string): boolean;
    export function contains(str: string, contains: string): boolean;
    export function replaceAll(str: string, old: string, new_: string): string;
    export function snakify(s: string): string;
    export function sortObjectFields<T>(o: T): T;
    export function chopArray<T>(arr: T[], chunkSize: number): T[][];
    export function unique<T>(arr: T[], f: (t: T) => string): T[];
    export function groupBy<T>(arr: T[], f: (t: T) => string): pxt.Map<T[]>;
    export function toDictionary<T>(arr: T[], f: (t: T) => string): pxt.Map<T>;
    export function toSet<T>(arr: T[], f: (t: T) => string): pxt.Map<boolean>;
    export function deepCopy(src: any): any;
    export interface ArrayLike<T> {
        [index: number]: T;
        length: number;
    }
    export function toArray<T>(a: ArrayLike<T> | ReadonlyArray<T>): T[];
    export function indexOfMatching<T>(arr: T[], f: (t: T) => boolean): number;
    export function nextTick(f: () => void): void;
    export function delay<T>(duration: number, value: T | Promise<T>): Promise<T>;
    export function delay(duration: number): Promise<void>;
    export function promiseMapAll<T, V>(values: T[], mapper: (obj: T) => Promise<V>): Promise<V[]>;
    export function promiseMapAllSeries<T, V>(values: T[], mapper: (obj: T) => Promise<V>): Promise<V[]>;
    export function promisePoolAsync<T, V>(maxConcurrent: number, inputValues: T[], handler: (input: T) => Promise<V>): Promise<V[]>;
    export function memoizeString<T>(createNew: (id: string) => T): (id: string) => T;
    export function promiseTimeout<T>(ms: number, promise: T | Promise<T>, msg?: string): Promise<T>;
    export interface DeferredPromise<T> {
        resolve: (value: T) => void;
        reject: (reason: any) => void;
        promise: Promise<T>;
    }
    export function defer<T>(): DeferredPromise<T>;
    export function memoize<S, T>(getId: (v: S) => string, createNew: (v: S) => T): (id: S) => T;
    export function debounce(func: (...args: any[]) => any, wait: number, immediate?: boolean): any;
    export class AdaptiveDebouncer {
        func: () => void;
        minDelay: number;
        maxDelay: number;
        slowdownFactor: number;
        private lastPoke;
        private recentGaps;
        private timeout;
        private wrapped;
        constructor(func: () => void, minDelay?: number, maxDelay?: number, slowdownFactor?: number);
        poke(): void;
        trigger(): void;
    }
    export function throttle(func: (...args: any[]) => any, wait: number, immediate?: boolean): any;
    export function randomPermute<T>(arr: T[]): void;
    export function randomPick<T>(arr: T[]): T;
    export function timeSince(time: number): string;
    export function unicodeToChar(text: string): string;
    export function escapeForRegex(str: string): string;
    export function stripUrlProtocol(str: string): string;
    export function normalizePath(path: string): string;
    export function pathJoin(a: string, b: string): string;
    export let isNodeJS: boolean;
    export interface HttpRequestOptions {
        url: string;
        method?: string;
        data?: any;
        headers?: pxt.Map<string>;
        allowHttpErrors?: boolean;
        allowGzipPost?: boolean;
        responseArrayBuffer?: boolean;
        forceLiveEndpoint?: boolean;
        successCodes?: number[];
        withCredentials?: boolean;
    }
    export interface HttpResponse {
        statusCode: number;
        headers: pxt.Map<string | string[]>;
        buffer?: any;
        text?: string;
        json?: any;
    }
    export function requestAsync(options: HttpRequestOptions): Promise<HttpResponse>;
    export function httpGetTextAsync(url: string): Promise<string>;
    export function httpGetJsonAsync(url: string): Promise<any>;
    export function httpPostJsonAsync(url: string, data: any): Promise<any>;
    export function stringToUint8Array(input: string): Uint8Array;
    export function uint8ArrayToString(input: ArrayLike<number>): string;
    export function fromUTF8(binstr: string): string;
    export function toUTF8(str: string, cesu8?: boolean): string;
    export function toHex(bytes: ArrayLike<number>): string;
    export function fromHex(hex: string): Uint8Array;
    export class PromiseQueue {
        promises: pxt.Map<(() => Promise<any>)[]>;
        enqueue<T>(id: string, f: () => Promise<T>): Promise<T>;
    }
    export class PromiseBuffer<T> {
        private waiting;
        private available;
        drain(): void;
        pushError(v: Error): void;
        push(v: T): void;
        shiftAsync(timeout?: number): Promise<T>;
    }
    export function now(): number;
    export function nowSeconds(): number;
    export function timeout(ms: number): Promise<void>;
    /**
     * Utility function to run an action with exponential backoff until a condition is met or a timeout occurs.
     * @param action - The main action to run.
     * @param isComplete - A function that checks if the result of the action indicates completion.
     * @param initialDelayMs - The starting delay to use between the initial attempt and any retry.
     * @param maxDelayMs - The maximum delay between retries.
     * @param timeoutMs - The total timeout for the operation.
     * @param timeoutErrorMsg - The error message to throw if the operation times out.
     * @param backoffFactor - The factor by which to increase the delay after each retry (default is 1.5).
     */
    export function runWithBackoffAsync<T>(action: () => Promise<T>, isComplete: (result: T) => boolean, initialDelayMs: number, maxDelayMs: number, timeoutMs: number, timeoutErrorMsg: string, backoffFactor?: number): Promise<T>;
    export let cpuUs: () => number;
    export function getMime(filename: string): "text/plain" | "text/html" | "text/css" | "application/javascript" | "image/jpeg" | "image/png" | "image/x-icon" | "text/cache-manifest" | "application/manifest+json" | "application/json" | "image/svg+xml" | "application/vnd.ms-fontobject" | "font/ttf" | "application/font-woff" | "application/font-woff2" | "text/markdown" | "application/xml" | "audio/m4a" | "audio/mp3" | "application/wasm" | "application/octet-stream";
    export function randomUint32(): number;
    export function guidGen(): string;
    export function downloadLiveTranslationsAsync(lang: string, filename: string, etag?: string): Promise<pxt.Map<string>>;
    export const pxtLangCookieId = "PXT_LANG";
    export const langCookieExpirationDays = 30;
    export interface Language {
        englishName: string;
        localizedName: string;
    }
    export const allLanguages: pxt.Map<Language>;
    export function isLocaleEnabled(code: string): boolean;
    interface LocalizationUpdateOptions {
        targetId: string;
        baseUrl: string;
        code: string;
        force?: boolean;
    }
    export function updateLocalizationAsync(opts: LocalizationUpdateOptions): Promise<void>;
    export enum TranslationsKind {
        Editor = 0,
        Sim = 1,
        Apis = 2,
        SkillMap = 3
    }
    export function downloadTranslationsAsync(targetId: string, baseUrl: string, code: string, live: boolean, translationKind?: TranslationsKind): Promise<pxt.Map<string>>;
    export let httpRequestCoreAsync: (options: HttpRequestOptions) => Promise<HttpResponse>;
    export let sha256: (hashData: string) => string;
    export let getRandomBuf: (buf: Uint8Array) => void;
    export function capitalize(n: string): string;
    export function uncapitalize(n: string): string;
    export function camelCaseToLowercaseWithSpaces(n: string): string;
    export function snakeCaseToLowercaseWithSpaces(n: string): string;
    export function range(len: number): number[];
    export function multipartPostAsync(uri: string, data?: any, filename?: string, filecontents?: string): Promise<HttpResponse>;
    export function toDataUri(data: string, mimetype?: string): string;
    export const imageMagic = 1496611453;
    export const imageHeaderSize = 36;
    export function encodeBlobAsync(canvas: HTMLCanvasElement, blob: Uint8Array): HTMLCanvasElement;
    export function decodeBlobAsync(dataURL: string): Promise<Uint8Array>;
    export function parseQueryString(qs: string): pxt.Map<string>;
    export function stringifyQueryString(url: string, qs: any): string;
    export function cloneTargetBundle(target: pxt.TargetBundle): pxt.TargetBundle;
    export function cloneApis(byQName: pxt.Map<pxtc.SymbolInfo>): pxt.Map<SymbolInfo>;
    export function cloneSymbolInfo(sym: pxtc.SymbolInfo): pxtc.SymbolInfo;
    export function toUTF8Array(s: string): Uint8Array;
    export function fromUTF8Array(s: Uint8Array): string;
    export function getHomeUrl(): string;
    export function isExperienceSupported(experienceId: string): boolean;
    export function ocvEnabled(): string;
    export function bresenhamLine(x0: number, y0: number, x1: number, y1: number, handler: (x: number, y: number) => void): void;
    /**
     * Check if the specified feature is enabled for the user (based on pxtarget configuration and region).
     */
    export function isFeatureEnabled(featureKey: string): boolean;
    /**
     * Remove potentially sensitive info from the given data to avoid logging it.
     * Currently only supports string data.
     */
    export function cleanData(data: string): string;
    export function cleanData(data: pxt.Map<string | number>): pxt.Map<string | number>;
    export {};
}
declare namespace ts.pxtc.BrowserImpl {
    function sha256buffer(buf: Uint8Array): string;
    function sha256string(s: string): string;
}
declare namespace ts.pxtc.jsonPatch {
    type AddOperation = {
        op: 'add';
        path: (string | number)[];
        value: string | number | boolean | object;
    };
    type ReplaceOperation = {
        op: 'replace';
        path: (string | number)[];
        value: string | number | boolean | object;
    };
    type RemoveOperation = {
        op: 'remove';
        path: (string | number)[];
    };
    type PatchOperation = AddOperation | ReplaceOperation | RemoveOperation;
    /**
     * Returns the diff of two objects as a set of change operations, following the
     * "JSON Patch" format: https://datatracker.ietf.org/doc/html/rfc6902 (with a
     * small difference to the way paths are encoded).
     */
    function diff(oldObj: any, newObj: any): PatchOperation[];
    /**
     * Applies a set of JSON Patch operations to the object.
     */
    function patchInPlace(obj: any, ops: PatchOperation[]): void;
    function opsAreEqual(a: PatchOperation, b: PatchOperation): boolean;
}
declare namespace ts.pxtc.jsonPatch.tests {
    function diffTests(): void;
    function patchTests(): void;
}
declare namespace pxt.perf {
    type EventSource<T> = {
        subscribe(listener: (ev: T) => void): () => void;
    };
    function isEnabled(): boolean;
    let perfReportLogged: boolean;
    function report(): {
        milestones: {
            [index: string]: number;
        };
        durations: {
            [index: string]: number;
        };
    } | undefined;
    function recordMilestone(msg: string, params?: Map<string>): void;
    function measureStart(name: string): void;
    function measureEnd(name: string, params?: Map<string>): void;
    let measurementThresholdMs: number;
    const stats: {
        milestones: EventSource<{
            milestone: string;
            time: number;
            params?: Map<string>;
        }>;
        durations: EventSource<{
            name: string;
            start: number;
            duration: number;
            params?: Map<string>;
        }>;
    };
}
declare namespace pxt {
    export import U = pxtc.Util;
    export import Util = pxtc.Util;
    interface TCPIO {
        onData: (v: Uint8Array) => void;
        onError: (e: Error) => void;
        connectAsync(): Promise<void>;
        sendPacketAsync(pkt: Uint8Array): Promise<void>;
        error(msg: string): any;
        disconnectAsync(): Promise<void>;
    }
    let mkTCPSocket: (host: string, port: number) => TCPIO;
    function setAppTarget(trg: TargetBundle): void;
    function setBundledApiInfo(inf: Map<PackageApiInfo>): void;
    function getBundledApiInfo(): Map<PackageApiInfo>;
    function savedAppTheme(): AppTheme;
    function setCompileSwitch(name: string, value: boolean): void;
    function setCompileSwitches(names: string): void;
    function bundledSvg(id: string): string;
    function replaceStringsInJsonBlob(blobPart: any, matcher: RegExp, matchHandler: (matchingString: string) => string): any;
    function reloadAppTargetVariant(temporary?: boolean): void;
    function setAppTargetVariant(variant: string, opts?: {
        force?: boolean;
        temporary?: boolean;
    }): void;
    let onAppTargetChanged: () => void;
    function setHwVariant(variant: string, name?: string): void;
    function hasHwVariants(): boolean;
    function getHwVariants(): PackageConfig[];
    function getActiveHwVariant(): string;
    interface PxtOptions {
        debug?: boolean;
        light?: boolean;
        wsPort?: number;
    }
    let options: PxtOptions;
    let reportException: (err: any, data?: Map<string | number>) => void;
    let reportError: (cat: string, msg: string, data?: Map<string | number>) => void;
    interface WebConfig {
        relprefix: string;
        workerjs: string;
        monacoworkerjs: string;
        gifworkerjs: string;
        serviceworkerjs: string;
        typeScriptWorkerJs: string;
        pxtVersion: string;
        pxtRelId: string;
        pxtCdnUrl: string;
        commitCdnUrl: string;
        blobCdnUrl: string;
        cdnUrl: string;
        targetUrl: string;
        targetVersion: string;
        targetRelId: string;
        targetId: string;
        simUrl: string;
        simserviceworkerUrl: string;
        simworkerconfigUrl: string;
        partsUrl?: string;
        runUrl?: string;
        docsUrl?: string;
        multiUrl?: string;
        asseteditorUrl?: string;
        skillmapUrl?: string;
        authcodeUrl?: string;
        multiplayerUrl?: string;
        kioskUrl?: string;
        teachertoolUrl?: string;
        isStatic?: boolean;
        verprefix?: string;
        ocv?: OcvConfig;
    }
    interface OcvConfig {
        appId: number;
        iframeEndpoint: string;
    }
    function localWebConfig(): WebConfig;
    let webConfig: WebConfig;
    function getOnlineCdnUrl(): string;
    function setupWebConfig(cfg: WebConfig): void;
    interface Host {
        readFile(pkg: Package, filename: string, skipAdditionalFiles?: boolean): string;
        writeFile(pkg: Package, filename: string, contents: string, force?: boolean): void;
        downloadPackageAsync(pkg: Package, deps?: string[]): Promise<void>;
        getHexInfoAsync(extInfo: pxtc.ExtensionInfo): Promise<pxtc.HexInfo>;
        cacheStoreAsync(id: string, val: string): Promise<void>;
        cacheGetAsync(id: string): Promise<string>;
    }
    interface FsFile {
        name: string;
        mtime: number;
        content?: string;
        prevContent?: string;
    }
    interface FsPkg {
        path: string;
        config: pxt.PackageConfig;
        header: pxt.workspace.Header;
        files: FsFile[];
        icon?: string;
        isDeleted?: boolean;
    }
    interface FsPkgs {
        pkgs: FsPkg[];
    }
    interface ICompilationOptions {
    }
    function getEmbeddedScript(id: string): Map<string>;
    function targetConfigAsync(): Promise<pxt.TargetConfig>;
    function packagesConfigAsync(): Promise<pxt.PackagesConfig>;
    const CONFIG_NAME = "pxt.json";
    const SIMSTATE_JSON = ".simstate.json";
    const SERIAL_EDITOR_FILE = "serial.txt";
    const README_FILE = "README.md";
    const GITIGNORE_FILE = ".gitignore";
    const ASSETS_FILE = "assets.json";
    const CLOUD_ID = "pxt/";
    const BLOCKS_PROJECT_NAME = "blocksprj";
    const JAVASCRIPT_PROJECT_NAME = "tsprj";
    const PYTHON_PROJECT_NAME = "pyprj";
    const MAIN_BLOCKS = "main.blocks";
    const MAIN_TS = "main.ts";
    const MAIN_PY = "main.py";
    const DEFAULT_GROUP_NAME = "other";
    const TILEMAP_CODE = "tilemap.g.ts";
    const TILEMAP_JRES = "tilemap.g.jres";
    const IMAGES_CODE = "images.g.ts";
    const IMAGES_JRES = "images.g.jres";
    const TUTORIAL_CODE_START = "_onCodeStart.ts";
    const TUTORIAL_CODE_STOP = "_onCodeStop.ts";
    const TUTORIAL_INFO_FILE = "tutorial-info-cache.json";
    const TUTORIAL_CUSTOM_TS = "tutorial.custom.ts";
    const BREAKPOINT_TABLET = 991;
    const PALETTES_FILE = "_palettes.json";
    const HISTORY_FILE = "_history";
    function outputName(trg?: pxtc.CompileTarget): "binary.uf2" | "binary.bin" | "binary.pxt64" | "binary.elf" | "binary.hex";
    function isOutputText(trg?: pxtc.CompileTarget): boolean;
}
declare namespace pxt.blocks {
    let showBlockIdInTooltip: boolean;
    interface PxtBlockly {
    }
    interface BlocklyModule {
    }
    let requirePxtBlockly: () => PxtBlockly;
    let requireBlockly: () => BlocklyModule;
    let registerFieldEditor: (selector: string, proto: any, validator?: any) => void;
    const MATH_FUNCTIONS: {
        unary: string[];
        binary: string[];
        infix: string[];
    };
    const ROUNDING_FUNCTIONS: string[];
    interface BlockParameter {
        actualName: string;
        type?: string;
        definitionName: string;
        definitionIndex?: number;
        shadowBlockId?: string;
        defaultValue?: string;
        isOptional?: boolean;
        fieldEditor?: string;
        fieldOptions?: Map<string>;
        shadowOptions?: Map<string>;
        range?: {
            min: number;
            max: number;
        };
    }
    interface BlockCompileInfo {
        parameters: ReadonlyArray<BlockParameter>;
        actualNameToParam: Map<BlockParameter>;
        definitionNameToParam: Map<BlockParameter>;
        handlerArgs?: HandlerArg[];
        thisParameter?: BlockParameter;
    }
    interface HandlerArg {
        name: string;
        type: string;
        inBlockDef: boolean;
        localizationKey: string;
    }
    const builtinFunctionInfo: pxt.Map<{
        params: string[];
        blockId: string;
    }>;
    function normalizeBlock(b: string, err?: (msg: string) => void): string;
    function compileInfo(fn: pxtc.SymbolInfo): BlockCompileInfo;
    function hasHandler(fn: pxtc.SymbolInfo): boolean;
    function getHelpUrl(fn: pxtc.SymbolInfo): string;
    /**
     * Returns which Blockly block type to use for an argument reporter based
     * on the specified TypeScript type.
     * @param varType The variable's TypeScript type
     * @return The Blockly block type of the reporter to be used
     */
    function reporterTypeForArgType(varType: string): string;
    function defaultIconForArgType(typeName?: string): "calculator" | "text width" | "random" | "list" | "align justify";
    interface FieldDescription {
        n: string;
        pre?: string;
        p?: string;
        ni: number;
    }
    function parseFields(b: string): FieldDescription[];
    interface BlockDefinition {
        name: string;
        category: string;
        url: string;
        tooltip?: string | Map<string>;
        operators?: Map<string[]>;
        block?: Map<string>;
        blockTextSearch?: string;
        tooltipSearch?: string;
        translationIds?: string[];
    }
    function blockDefinitions(): Map<BlockDefinition>;
    function getBlockDefinition(blockId: string): BlockDefinition;
}
declare namespace pxt.BrowserUtils {
    export function isDocumentVisible(): boolean;
    export function isIFrame(): boolean;
    export function hasNavigator(): boolean;
    export function hasWindow(): boolean;
    export function isWindows(): boolean;
    export function isWindows10(): boolean;
    export function isMobile(): boolean;
    export function isIOS(): boolean;
    export function isAndroid(): boolean;
    export function isMac(): boolean;
    export function isLinux(): boolean;
    export function isARM(): boolean;
    export function isEdge(): boolean;
    export function isChromiumEdge(): boolean;
    export function isIE(): boolean;
    export function isChrome(): boolean;
    export function isSafari(): boolean;
    export function isFirefox(): boolean;
    export function isOpera(): boolean;
    export function isMidori(): boolean;
    export function isEpiphany(): boolean;
    export function isTouchEnabled(): boolean;
    export function isPxtElectron(): boolean;
    export function isIpcRenderer(): boolean;
    export function isElectron(): boolean;
    export let isWinRT: () => boolean;
    export function isLocalHost(ignoreFlags?: boolean): boolean;
    export function isLocalHostDev(): boolean;
    export function isSkillmapEditor(): boolean;
    export function isTabletSize(): boolean;
    export function isComputerSize(): boolean;
    export function isInGame(): boolean;
    export function hasFileAccess(): boolean;
    export function noSharedLocalStorage(): boolean;
    export function useOldTutorialLayout(): boolean;
    export function hasPointerEvents(): boolean;
    export function os(): string;
    export function browser(): string;
    export function browserVersion(): string;
    export function isBrowserSupported(): boolean;
    export function devicePixelRatio(): number;
    export function browserDownloadBinText(text: string, name: string, opt?: BrowserDownloadOptions): string;
    export function browserDownloadText(text: string, name: string, opt?: BrowserDownloadOptions): string;
    export function isBrowserDownloadInSameWindow(): boolean;
    export function isBrowserDownloadWithinUserContext(): boolean;
    export function browserDownloadDataUri(uri: string, name: string, userContextWindow?: Window): void;
    export function browserDownloadUInt8Array(buf: Uint8Array, name: string, opt?: BrowserDownloadOptions): string;
    export function toDownloadDataUri(b64: string, contentType: string): string;
    export interface BrowserDownloadOptions {
        contentType?: string;
        userContextWindow?: Window;
        onError?: (err: any) => void;
        maintainObjectURL?: boolean;
    }
    export function browserDownloadBase64(b64: string, name: string, opt?: BrowserDownloadOptions): string;
    export function loadImageAsync(data: string): Promise<HTMLImageElement>;
    export function loadCanvasAsync(url: string): Promise<HTMLCanvasElement>;
    export function scaleImageData(img: ImageData, scale: number): ImageData;
    export function imageDataToPNG(img: ImageData, scale?: number): string;
    export function encodeToPngAsync(uri: string, options?: {
        width?: number;
        height?: number;
        pixelDensity?: number;
        maxSize?: number;
        text?: string;
    }): Promise<string>;
    export function resolveCdnUrl(path: string): string;
    export function loadStyleAsync(path: string, rtl?: boolean): Promise<void>;
    export function loadScriptAsync(path: string): Promise<void>;
    export function loadAjaxAsync(url: string): Promise<string>;
    export function loadBlocklyAsync(): Promise<void>;
    export function patchCdn(url: string): string;
    export function initTheme(): void;
    /**
     * Utility method to change the hash.
     * Pass keepHistory to retain an entry of the change in the browser history.
     */
    export function changeHash(hash: string, keepHistory?: boolean): void;
    /**
     * Simple utility method to join urls.
     */
    export function urlJoin(urlPath1: string, urlPath2: string): string;
    /**
     * Simple utility method to join multiple urls.
     */
    export function joinURLs(...parts: string[]): string;
    export function storageEstimateAsync(): Promise<{
        quota?: number;
        usage?: number;
    }>;
    export const scheduleStorageCleanup: any;
    export function stressTranslationsAsync(): Promise<void>;
    export interface ITranslationDbEntry {
        id?: string;
        etag: string;
        time: number;
        strings?: pxt.Map<string>;
        md?: string;
    }
    export interface ITranslationDb {
        getAsync(lang: string, filename: string): Promise<ITranslationDbEntry>;
        setAsync(lang: string, filename: string, etag: string, strings?: pxt.Map<string>, md?: string): Promise<void>;
        clearAsync(): Promise<void>;
    }
    export type IDBUpgradeHandler = (ev: IDBVersionChangeEvent, request: IDBRequest) => void;
    export class IDBWrapper {
        private name;
        private version;
        private upgradeHandler?;
        private quotaExceededHandler?;
        private skipErrorLog;
        private _db;
        constructor(name: string, version: number, upgradeHandler?: IDBUpgradeHandler, quotaExceededHandler?: () => void, skipErrorLog?: boolean);
        private throwIfNotOpened;
        private errorHandler;
        private getObjectStore;
        static deleteDatabaseAsync(name: string): Promise<void>;
        openAsync(): Promise<void>;
        getAsync<T>(storeName: string, id: string): Promise<T>;
        getAllAsync<T>(storeName: string): Promise<T[]>;
        setAsync(storeName: string, data: any): Promise<void>;
        deleteAsync(storeName: string, id: string): Promise<void>;
        deleteAllAsync(storeName: string): Promise<void>;
        getObjectStoreWrapper<T>(storeName: string): IDBObjectStoreWrapper<T>;
    }
    export class IDBObjectStoreWrapper<T> {
        protected db: IDBWrapper;
        protected storeName: string;
        constructor(db: IDBWrapper, storeName: string);
        getAsync(id: string): Promise<T>;
        getAllAsync(): Promise<T[]>;
        setAsync(data: T): Promise<void>;
        deleteAsync(id: string): Promise<void>;
        deleteAllAsync(): Promise<void>;
    }
    export function translationDbAsync(): Promise<ITranslationDb>;
    export function clearTranslationDbAsync(): Promise<void>;
    export function getTutorialCodeHash(code: string[]): string;
    interface TutorialInfoIndexedDbEntry {
        id: string;
        time: number;
        hash: string;
        blocks: Map<number>;
        snippets: Map<Map<number>>;
        highlightBlocks: Map<Map<number>>;
        validateBlocks: Map<Map<string[]>>;
    }
    export interface ITutorialInfoDb {
        getAsync(filename: string, code: string[], branch?: string): Promise<TutorialInfoIndexedDbEntry>;
        setAsync(filename: string, snippets: Map<Map<number>>, code: string[], highlights: Map<Map<number>>, codeValidationMap: Map<Map<string[]>>, branch?: string): Promise<void>;
        clearAsync(): Promise<void>;
    }
    class TutorialInfoIndexedDb implements ITutorialInfoDb {
        protected readonly db: pxt.BrowserUtils.IDBWrapper;
        static TABLE: string;
        static KEYPATH: string;
        static dbName(): string;
        static createAsync(): Promise<TutorialInfoIndexedDb>;
        private constructor();
        getAsync(filename: string, code: string[], branch?: string): Promise<TutorialInfoIndexedDbEntry>;
        setAsync(filename: string, snippets: Map<Map<number>>, code: string[], highlights: Map<Map<number>>, codeValidationMap: Map<Map<string[]>>, branch?: string): Promise<void>;
        setWithHashAsync(filename: string, snippets: Map<Map<number>>, hash: string, highlights: Map<Map<number>>, codeValidationMap: Map<Map<string[]>>, branch?: string): Promise<void>;
        clearAsync(): Promise<void>;
    }
    export function tutorialInfoDbAsync(): Promise<TutorialInfoIndexedDb>;
    export function clearTutorialInfoDbAsync(): Promise<void>;
    export interface IPointerEvents {
        up: string;
        down: string[];
        move: string;
        enter: string;
        leave: string;
    }
    export const pointerEvents: IPointerEvents;
    export function getPageX(event: any): number;
    export function getPageY(event: any): number;
    export function getClientX(event: any): number;
    export function getClientY(event: any): number;
    export function popupWindow(url: string, title: string, popUpWidth: number, popUpHeight: number): Window;
    export function containsClass(el: SVGElement | HTMLElement, classes: string): boolean;
    export function addClass(el: SVGElement | HTMLElement, classes: string): void;
    export function removeClass(el: SVGElement | HTMLElement, classes: string): void;
    export function getCookieLang(): string;
    export function setCookieLang(langId: string, docs?: boolean): void;
    export function cacheBustingUrl(url: string): string;
    export function appendUrlQueryParams(url: string, params: URLSearchParams): string;
    export function legacyCopyText(element: HTMLInputElement | HTMLTextAreaElement): boolean;
    /**
     * Sets the theme of the application by adding a class to the body. Themes
     * are defined in CSS variable packs. The default theme is defined in
     * `themes/themepacks.less`, in the `:root` pseudoclass. `highcontrast` is
     * also defined there. Target-specific themes are defined in the target
     * repo's `theme/themepack.less`.
     */
    export function setApplicationTheme(theme: string | undefined): void;
    export function isElement(node: Node): node is Element;
    export {};
}
declare namespace pxt.cloud {
    export type DevBackendType = "default" | "prod" | "staging" | "localhost";
    const DEV_BACKEND_PROD = "https://makecode.com";
    const DEV_BACKEND_STAGING = "https://staging.pxt.io";
    const DEV_BACKEND_LOCALHOST = "http://localhost:8080";
    type BackendUrls = typeof DEV_BACKEND_PROD | typeof DEV_BACKEND_STAGING | typeof DEV_BACKEND_LOCALHOST;
    export const DEV_BACKEND: BackendUrls;
    export const DEV_REGION = "US";
    export function devBackendType(): DevBackendType;
    export type CloudStatus = "none" | "synced" | "justSynced" | "offline" | "syncing" | "conflict" | "localEdits";
    export type CloudStatusInfo = {
        value: pxt.cloud.CloudStatus;
        icon?: string;
        tooltip?: string;
        shortStatus?: string;
        longStatus?: string;
        indicator?: string;
    };
    export const cloudStatus: {
        [index in pxt.cloud.CloudStatus]: CloudStatusInfo;
    };
    export {};
}
declare namespace pxt.commands {
    enum WebUSBPairResult {
        Failed = 0,
        Success = 1,
        UserRejected = 2
    }
    interface RecompileOptions {
        recompile: boolean;
        useVariants: string[];
    }
    interface DeployOptions {
        reportError: (e: string) => void;
        showNotification: (msg: string) => void;
    }
    type DeployFnAsync = (r: ts.pxtc.CompileResult, d?: DeployOptions) => Promise<void>;
    let deployCoreAsync: DeployFnAsync;
    let deployFallbackAsync: DeployFnAsync;
    let hasDeployFn: () => DeployFnAsync;
    let deployAsync: DeployFnAsync;
    let patchCompileResultAsync: (r: pxtc.CompileResult) => Promise<void>;
    let browserDownloadAsync: (text: string, name: string, contentType: string) => Promise<void>;
    let saveOnlyAsync: (r: ts.pxtc.CompileResult) => Promise<void>;
    let renderBrowserDownloadInstructions: (saveOnly?: boolean, redeploy?: () => Promise<void>) => any;
    let renderUsbPairDialog: (firmwareUrl?: string, failedOnce?: boolean) => any;
    let renderIncompatibleHardwareDialog: (unsupportedParts: string[]) => any;
    let renderDisconnectDialog: () => {
        header: string;
        jsx: any;
        helpUrl: string;
    };
    let showUsbDeviceForgottenDialog: (confirmAsync: (options: any) => Promise<number>) => Promise<void>;
    let showUploadInstructionsAsync: (fn: string, url: string, confirmAsync: (options: any) => Promise<number>, saveOnly?: boolean, redeploy?: () => Promise<void>) => Promise<void>;
    let showProgramTooLargeErrorAsync: (variants: string[], confirmAsync: (options: any) => Promise<number>, saveOnly?: boolean) => Promise<RecompileOptions>;
    let saveProjectAsync: (project: pxt.cpp.HexFile) => Promise<void>;
    let electronDeployAsync: (r: ts.pxtc.CompileResult) => Promise<void>;
    let electronFileDeployAsync: (deployRequest: pxt.electron.FileDeployRequest) => Promise<void>;
    let webUsbPairDialogAsync: (pairAsync: () => Promise<boolean>, confirmAsync: (options: any) => Promise<WebUSBPairResult>, implicitlyCalled?: boolean) => Promise<WebUSBPairResult>;
    let onTutorialCompleted: () => void;
    let onPostHostMessage: (msg: any) => void;
    let perfMeasurementThresholdMs: number;
    let onPerfMilestone: (payload: {
        milestone: string;
        time: number;
        params?: Map<string>;
    }) => void;
    let onPerfMeasurement: (payload: {
        name: string;
        start: number;
        duration: number;
        params?: Map<string>;
    }) => void;
    let workspaceLoadedAsync: () => Promise<void>;
    let getDownloadMenuItems: () => any[];
    let notifyProjectCompiled: (headerId: string, compileResult: pxtc.CompileResult) => void;
    let notifyProjectSaved: (header: pxt.workspace.Header) => void;
    let onDownloadButtonClick: () => Promise<void>;
    let getDefaultProjectName: () => string;
    let onMarkdownActivityLoad: (path: string, title?: string, editorProjectName?: string) => Promise<void>;
}
declare namespace pxt {
    function getWhiteContrastingBackground(color: string): string;
    function contrastRatio(fg: string, bg: string): number;
}
declare namespace Measurements {
    const TutorialInfoDbSetAsync = "tutorial info db setAsync";
    const ReloadAppTargetVariant = "reloadAppTargetVariant";
    const Sha256Buffer = "sha256buffer";
    const WebworkerRecvHandler = "webworker recvHandler";
    const NetworkRequest = "network.request";
}
declare namespace pxt {
    function lzmaDecompressAsync(buf: Uint8Array): Promise<string>;
    function lzmaCompressAsync(text: string): Promise<Uint8Array>;
}
declare namespace pxt.cpp {
    function nsWriter(nskw?: string): {
        setNs: (ns: string, over?: string) => void;
        clear: () => void;
        write: (s: string) => void;
        incrIndent: () => void;
        decrIndent: () => void;
        finish: () => string;
    };
    function parseCppInt(v: string): number;
    class PkgConflictError extends Error {
        pkg0: Package;
        pkg1: Package;
        settingName: string;
        isUserError: boolean;
        isVersionConflict: boolean;
        constructor(msg: string);
    }
    function getExtensionInfo(mainPkg: MainPackage): pxtc.ExtensionInfo;
    interface HexFileMeta {
        cloudId: string;
        targetVersions?: pxt.TargetVersions;
        editor: string;
        name: string;
    }
    interface HexFile {
        meta?: HexFileMeta;
        source: string;
    }
    function unpackSourceFromHexFileAsync(file: File): Promise<HexFile>;
    function unpackSourceFromHexAsync(dat: Uint8Array): Promise<HexFile>;
}
declare namespace pxt.hexloader {
    let showLoading: (msg: string) => void;
    let hideLoading: () => void;
    function storeWithLimitAsync(host: Host, idxkey: string, newkey: string, newval: string, maxLen?: number): Promise<void>;
    function recordGetAsync(host: Host, idxkey: string, newkey: string): Promise<void>;
    function getHexInfoAsync(host: Host, extInfo: pxtc.ExtensionInfo, cloudModule?: any): Promise<pxtc.HexInfo>;
}
declare namespace pxt.crowdin {
    const KEY_VARIABLE = "CROWDIN_KEY";
    let testMode: boolean;
    function setTestMode(): void;
    function inContextLoadAsync(text: string): Promise<string>;
}
declare namespace pxt.diff {
    export function toLines(file: string, includeNewline