@microtronics/studio-cli 1.2.0-alpha.1 → 1.2.0-alpha.10

package/dist/studio-cli.d.ts

@@ -1,9 +1,19 @@
+import { AtCommandHandler } from '@microtronics/device-master';
+import { DdeModel } from '@microtronics/device-master';
+import { DdeRecord } from '@microtronics/device-master';
 import { Document as Document_2 } from 'yaml';
+import { EventEmitter } from 'node:events';
+import { ITimeSource } from '@microtronics/device-master';
+import { ITransport } from '@microtronics/device-master';
 import { LineCounter } from 'yaml';
+import { LocalApiRequest } from '@microtronics/device-master';
+import { LocalApiResponse } from '@microtronics/device-master';
+import { MemoryStorage } from '@microtronics/device-master';
 import { ParsedNode } from 'yaml';
 import { Range as Range_2 } from 'yaml';
 import { SemVer } from 'semver';
 import { URI } from 'vscode-uri';
+import { UtoMaster } from '@microtronics/device-master';
 
 export declare namespace APM {
     export enum TagPhase {
@@ -395,6 +405,18 @@ declare interface components {
     pathItems: never;
 }
 
+/** One tag whose device stamp overtook the mirror and was therefore pulled. */
+export declare interface ContainerChange {
+    tag: number;
+    /** DDE container name, when the tag maps to one. */
+    container: string | null;
+    alias?: string;
+    /** Device stamp40 the mirror now holds. */
+    stamp: number;
+    /** Decoded record, for tags that map to a DDE container. */
+    decoded?: DdeRecord | null;
+}
+
 declare const createPawnCC: PawnModuleFactory;
 
 declare const createPawnDbg: PawnModuleFactory;
@@ -1776,6 +1798,8 @@ export declare namespace DefaultFiles {
         legacyAutoUplinkInc: string;
         reportTemplate: string;
         dloCfg: string;
+        devMirror: string;
+        devDeviceLog: string;
     };
     export const filePaths: {
         studio: {
@@ -1801,6 +1825,11 @@ export declare namespace DefaultFiles {
                 };
             };
             libdeps: string;
+            dev: {
+                path: string;
+                mirror: string;
+                deviceLog: string;
+            };
         };
         dist: {
             path: string;
@@ -1985,6 +2014,15 @@ export declare namespace Dependencies {
      * @param logger
      */
     export function normalizeInstalledLibraryParts(cwd: URI, fs: LocalFS, logger: Log.Logger): Promise<void>;
+    /**
+     * Validate that every installed library dependency (direct and transitive, including dev dependencies)
+     * requires a minimum server version ("engines.backend") that the current project (application or library)
+     * already satisfies. Does not modify the manifest - raising "engines.backend" stays an explicit developer decision.
+     * @param cwd
+     * @param fs
+     * @param logger
+     */
+    export function validateMinimumBackendVersion(cwd: URI, fs: LocalFS, logger: Log.Logger): Promise<void>;
     /**
      * Install npm dependencies in pov and blo working paths if they exist and contain a package.json.
      * This ensures that a single `studio install` command sets up the entire project.
@@ -2028,6 +2066,39 @@ export declare namespace Dependencies {
     export function unlinkLibraryApmParts(cwd: URI, fs: LocalFS, logger: Log.Logger, libraryName: string): Promise<void>;
 }
 
+/**
+ * Start a `studio dev` session and its local HTTP server.
+ *
+ * Build → connect USB → flash → parse `dist/dde/dde.xml` → serve the myDatanet-compatible
+ * `/api/**` surface plus `/dev/**` and `/events` on localhost.
+ */
+export declare function dev(cwd: URI, fs: LocalFS, options: DevOptions): Promise<DevResult>;
+
+/** Diagnostics of the last `build()`, as served by `/dev/status` and `/dev/build`. */
+export declare interface DevBuildState {
+    running: boolean;
+    ok: boolean | null;
+    at: number | null;
+    message?: string;
+    diagnostics?: Package.MergedDiagnostics;
+}
+
+/** `GET /dev/configs` payload — every config-class container, decoded and alias-or-name keyed. */
+declare interface DevConfigs {
+    configs: Record<string, unknown>;
+    /** Keys of {@link DevConfigs.configs}, in DDE declaration order. */
+    order: string[];
+}
+
+/** One entry of the `PUT /dev/configs` response — mirrors the single-container write outcome. */
+declare type DevConfigWriteResult = {
+    ok: true;
+    stale?: true;
+} | {
+    ok: false;
+    err: string;
+};
+
 /**
  * Development installation information
  */
@@ -2045,8 +2116,348 @@ export declare interface DevelopmentInstallInfo {
     registrationCodeNeeded?: boolean;
 }
 
+/** An error carrying the process exit code the CLI should terminate with. */
+export declare class DevError extends Error {
+    readonly exitCode: DevExitCode;
+    constructor(message: string, exitCode: DevExitCode);
+}
+
+/**
+ * Exit codes for `studio dev` / `studio device`. 0–3 mirror
+ * {@link import('../myDatanetClient').RunExitCode}; 7–9 are dev-mode specific.
+ */
+export declare enum DevExitCode {
+    Success = 0,
+    BuildFailed = 1,
+    DeviceNotFound = 2,
+    UsbFailed = 3,
+    ModelMissing = 7,
+    UnknownContainer = 8,
+    WriteForbidden = 9
+}
+
 export declare const DeviceProfiles: any;
 
+/**
+ * The pair of transports (UTO data + AT debug) needed to talk to a connected device,
+ * plus a way to release the underlying link.
+ */
+export declare interface DeviceTransports {
+    uto: ITransport;
+    /** Absent when the caller asked for the UTO interface only (`needDebug: false`). */
+    debug?: ITransport;
+    close(): Promise<void>;
+}
+
+/** One ring-buffer record, as served by `GET /dev/logs` and the SSE `log` event. */
+export declare interface DevLogRecord {
+    /** Monotonic sequence number; `GET /dev/logs?since=<seq>` returns everything after it. */
+    seq: number;
+    /** Wall-clock ms. */
+    ts: number;
+    source: DevLogSource;
+    text: string;
+    /** Base64 payload, only for records whose bytes could not be decoded to text. */
+    raw?: string;
+}
+
+/** Where a log record came from. `state`/`console` are only used by `--replay` (`dev/replay/replaySession.ts`). */
+export declare type DevLogSource = 'rm2mlog' | 'at' | 'uto' | 'pov' | 'state' | 'console';
+
+export declare interface DevOptions {
+    /** Required unless {@link DevOptions.replay} is given. */
+    serial?: string;
+    host?: string;
+    port?: number;
+    /** Allow a non-loopback `host` without a bearer token. */
+    allowRemote?: boolean;
+    /** Rebuild, flash and sync on source changes. */
+    watch?: boolean;
+    /** Build before connecting (default `true`). */
+    build?: boolean;
+    /** Flash `dist/dlo/main.amx` after connecting (default `true`). */
+    flash?: boolean;
+    pollIntervalMs?: number;
+    /** How long a write waits for the device to confirm, in ms. */
+    waitMs?: number;
+    logFile?: string;
+    /** Bearer token required by the server; absent ⇒ `Authorization` is ignored. */
+    token?: string;
+    part?: APM.Part[];
+    debug?: boolean;
+    env?: Globals.ENV;
+    apiToken?: string | null;
+    logger?: Log.Logger;
+    /** Spawn `npm run dev -w pov/<name>` with `MYDATANET_HOST` pointing at this server. */
+    pov?: string | boolean;
+    /** Persist the mirror to `.studio/dev/mirror.json` (default `true`). */
+    persistMirror?: boolean;
+    /** Test seam, forwarded to {@link DevSession}. */
+    transportFactory?: TransportFactory;
+    createDevice?: DevSessionOptions['createDevice'];
+    /**
+     * Support/forensics mode: replay a companion-app flight-recorder export instead of
+     * opening USB (`cli/src/dev/replay/*`). Mutually exclusive with a live device — no
+     * `build`/`flash`/poller/watch run, and `/api/**` answers empty/`E_EOD`.
+     */
+    replay?: string;
+    /** Explicit recording session id; default = the session with the most records. */
+    session?: string;
+    /** Replay speed; `0`/`'max'` disables recorded delays. Default `1` (real-time). */
+    speed?: number | 'max';
+}
+
+/** Recording metadata reported by a `--replay` session (`dev/replay/replaySession.ts`). */
+declare interface DevReplayStatus {
+    mode: 'replay';
+    /** The cassette file this session was started from. */
+    file: string;
+    session: string;
+    serial: string | null;
+    deviceId: string | null;
+    appVersion: string | null;
+    platform: string | null;
+    recordCount: number;
+    startedTs: number;
+    endedTs: number | null;
+    speed: number | 'max';
+}
+
+export declare interface DevResult {
+    url: string;
+    port: number;
+    session: DevServerSession;
+    apmId: string;
+    close(): Promise<void>;
+}
+
+export declare interface DevServer {
+    url: string;
+    port: number;
+    close(): Promise<void>;
+}
+
+/** The `/dev/logs` ring-buffer surface — shared by {@link DevServerSession} implementations. */
+declare interface DevServerLogStream {
+    readonly lastSeq: number;
+    since(since?: number, limit?: number): DevLogRecord[];
+}
+
+/**
+ * The subset of `DevSession` this server actually calls. A `--replay` session
+ * (`dev/replay/replaySession.ts`'s `ReplayDevSession`) implements this directly instead of
+ * a real `DevSession` — everything below is what `startDevServer` needs and nothing more.
+ */
+export declare interface DevServerSession {
+    readonly serial: string;
+    readonly logStream: DevServerLogStream;
+    on(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    handleApi(req: LocalApiRequest): Promise<LocalApiResponse>;
+    status(): DevStatus;
+    build(): Promise<DevBuildState>;
+    flash(file?: string): Promise<UploadResult>;
+    sync(tags?: number[]): Promise<{
+        tags: number[];
+        at: number;
+    }>;
+    at(cmd: string): Promise<string>;
+    state(): Promise<unknown>;
+    localDataSnapshot(): unknown;
+    measure(): Promise<unknown>;
+    configs(): Promise<DevConfigs>;
+    applyConfigs(body: Record<string, unknown>): Promise<Record<string, DevConfigWriteResult>>;
+}
+
+/**
+ * One `studio dev` session: owns the USB link, the project's DDE model, the `IStorage`
+ * mirror and the myDatanet-compatible API handler, and fans device activity out as events.
+ *
+ * Events: `log` ({@link DevLogRecord}), `state`, `sync`, `build`, `uto`,
+ * `container-changed` ({@link ContainerChange}), `error`.
+ */
+export declare class DevSession extends EventEmitter {
+    readonly logStream: LogStream;
+    private readonly opts;
+    private readonly logger;
+    private readonly timeSource;
+    private device;
+    private mirror;
+    private model;
+    private mapper;
+    private apiHandler;
+    private poller;
+    private stateManager;
+    private localData;
+    private offlineSync;
+    private buildState;
+    private lastSyncAt;
+    private firmwareVersion;
+    private mirrorSaveTimer;
+    private stopped;
+    private readonly lock;
+    constructor(options: DevSessionOptions);
+    get serial(): string;
+    get connected(): boolean;
+    /**
+     * Read by {@link StampPoller}: true while a flash, sync, write or AT command owns the
+     * UTO link, so a poll tick cannot interleave with a multi-frame transfer.
+     */
+    get busy(): boolean;
+    /** The parsed project DDE. */
+    get ddeModel(): DdeModel;
+    get storage(): MemoryStorage;
+    /**
+     * Build (optional) → load the model → connect USB → flash (optional) → start the stamp
+     * poller. Rejects with a {@link DevError} whose `exitCode` the CLI exits with.
+     */
+    start(): Promise<void>;
+    /** Read and parse `dist/dde/dde.xml`. Missing → {@link DevExitCode.ModelMissing}. */
+    private loadModel;
+    private connect;
+    private startPoller;
+    private tagLabel;
+    private get utoMaster();
+    private get atHandler();
+    /** Assemble the {@link LocalApiContext} and bind the router to it. */
+    private buildApiHandler;
+    /**
+     * Synthesize a {@link SiteBlueprint} from the parsed DDE, standing in for the site
+     * blueprint a real myDatanet backend would serve. Restores each container's fields'
+     * original-case DDE alias/name — the only thing `resolveBlueprintNameMap` reads.
+     */
+    private buildBlueprint;
+    /**
+     * Serve one `/api/**` request. A successful write additionally triggers an immediate
+     * poll tick and waits (bounded by `waitMs`) until the device's own stamp for the
+     * written tag has reached the pushed stamp — proof the device accepted the frame.
+     * When it does not, `x-mt-mirror: stale` is added; `?async=1` skips the wait entirely.
+     */
+    handleApi(req: LocalApiRequest): Promise<LocalApiResponse>;
+    /**
+     * The `uto_data` tag a request writes, or `null` for a read / an `?async=1` write /
+     * a path whose container cannot be resolved.
+     */
+    private writtenTag;
+    /**
+     * Poll until the device reports a stamp ≥ `pushedStamp` for `tag`, or the wait budget
+     * runs out. Returns `false` on timeout.
+     */
+    private awaitDeviceStamp;
+    /** Run the project build; records diagnostics in {@link DevBuildState}. */
+    build(): Promise<DevBuildState>;
+    /**
+     * Upload an AMX to the device (defaults to `dist/dlo/main.amx`).
+     *
+     * `uploadToDevice` owns its own connection, and a USB device is single-owner, so the
+     * session's link is released for the duration and reopened afterwards. The tag table
+     * can change with a new app, so DEVINFO is re-read before the poller resumes.
+     */
+    flash(file?: string): Promise<UploadResult>;
+    /**
+     * Reopen the USB link after a flash. The device is rebooting — and some devices don't even
+     * drop the USB connection — so a failure here is expected and retried for a while rather
+     * than reported immediately; a final failure is logged and leaves `connected: false`.
+     */
+    private reconnect;
+    private reportReconnectFailure;
+    /** Full `OfflineSyncManager` sync, or a targeted pull of the given tags. */
+    sync(tags?: number[]): Promise<{
+        tags: number[];
+        at: number;
+    }>;
+    /** One AT command; queued behind a flash, which closes the AT handler's transport. */
+    at(cmd: string): Promise<string>;
+    /** Last known rm2m state; fetches one when nothing has been read yet. */
+    state(): Promise<unknown>;
+    /** Live local-data values. */
+    localDataSnapshot(): unknown;
+    /** Trigger a measurement and return its outcome plus the fresh values. */
+    measure(): Promise<unknown>;
+    status(): DevStatus;
+    /** Config-class containers (`settings`/`config0..9`/`configA..C`) in DDE declaration order. */
+    private configContainers;
+    /**
+     * `GET /dev/configs` — one entry per config-class container, decoded through
+     * {@link handleApi} (the same path `GET /api/1/sites/<uid>/containers/<name>` uses). Keyed
+     * by the container's alias when the DDE declares one, else its raw name.
+     */
+    configs(): Promise<DevConfigs>;
+    /**
+     * `PUT /dev/configs` — applies each entry as a partial write via {@link handleApi}, exactly
+     * like `PUT /api/1/sites/<uid>/containers/<name>`. Accepts an alias or a raw container name
+     * as key; a key that resolves to no container, or to a non-config-class one, fails that
+     * entry alone with the same `{err}` wording the single-container route produces — the rest
+     * of the entries still apply.
+     */
+    applyConfigs(body: Record<string, unknown>): Promise<Record<string, DevConfigWriteResult>>;
+    /** Force one poll pass (used by the watcher and by `POST /dev/sync`). */
+    tick(): Promise<ContainerChange[]>;
+    /** The mirror's current stamp40 for a tag, or 0. */
+    mirrorStamp(tag: number): Promise<number>;
+    /** Run `fn` as the sole owner of the UTO link (see {@link UtoLock}). */
+    private withLink;
+    private closeDevice;
+    stop(): Promise<void>;
+}
+
+export declare interface DevSessionOptions {
+    cwd: URI;
+    fs: LocalFS;
+    /** 16-character hex device serial. */
+    serial: string;
+    /** Overrides how the USB transports are obtained (tests, later `--replay`). */
+    transportFactory?: TransportFactory;
+    /**
+     * Test seam: supply the connected device (UtoMaster + AtCommandHandler) instead of
+     * opening USB. The unit tests use it because `UtoMaster.init()` needs the real WASM
+     * UTO wire protocol, which a byte-level mock cannot produce.
+     */
+    createDevice?: (serial: string) => Promise<OpenDevice>;
+    /** Stamp-poll interval in ms; `0` disables polling. */
+    pollIntervalMs?: number;
+    /** Flash `dist/dlo/main.amx` to the device on start. */
+    flash: boolean;
+    /** Build the project on start. */
+    build: boolean;
+    part?: APM.Part[];
+    logger: Log.Logger;
+    timeSource?: ITimeSource;
+    env?: Globals.ENV;
+    apiToken?: string | null;
+    /** How long a write waits for the device to confirm, in ms. `0` disables the wait. */
+    waitMs?: number;
+    /** JSONL log file for every {@link DevLogRecord}. */
+    logFile?: string;
+    /** Persist the mirror to `.studio/dev/mirror.json`. */
+    persistMirror?: boolean;
+    debug?: boolean;
+    /** Test seam: replaces the AMX upload {@link flash} performs. */
+    uploadToDevice?: typeof uploadToDevice;
+    /** How long UTO work waits for the link while a flash owns it, in ms. */
+    lockWaitMs?: number;
+}
+
+/** `GET /dev/status` payload — `replay` is only present for a `--replay` session. */
+export declare interface DevStatus {
+    serial: string;
+    connected: boolean;
+    apmId: string;
+    firmwareVersion: string | null;
+    model: {
+        containers: Array<{
+            name: string;
+            alias?: string;
+            kind: string;
+            tag: number | null;
+        }>;
+    };
+    lastSync: number | null;
+    buildState: DevBuildState;
+    poll: StampPollerStatus;
+    replay?: DevReplayStatus;
+}
+
 export declare namespace DFILES {
     export enum Type {
         static = "static",
@@ -2589,7 +3000,8 @@ export declare namespace Log {
         done = 1,
         info = 2,
         warning = 3,
-        error = 4
+        error = 4,
+        debug = 5
     }
     export const LOG_PREFIX: {
         1: string;
@@ -2597,17 +3009,25 @@ export declare namespace Log {
         2: string;
         3: string;
         4: string;
+        5: string;
     };
     export class Logger {
         private _logHandler;
         private _silent;
+        private _debugEnabled;
         constructor(logOutput?: {
             log: (...args: any[]) => void;
         });
         _log(type: LogMessageType, msg: any, ...args: any[]): void;
         set silent(value: boolean);
+        /** Redirect where log lines go (e.g. stderr while stdout carries machine-readable output). */
+        set output(logOutput: {
+            log: (...args: any[]) => void;
+        });
         log(msg: any, ...args: any[]): void;
+        /** Only prints when {@link debugEnabled} is set (the `--debug` flag). */
         debug(msg: any, ...args: any[]): void;
+        set debugEnabled(value: boolean);
         error(msg: any, ...args: any[]): void;
         info(msg: any, ...args: any[]): void;
         warn(msg: any, ...args: any[]): void;
@@ -2615,6 +3035,58 @@ export declare namespace Log {
     }
 }
 
+/**
+ * Ring buffer of device log records with SSE fan-out.
+ *
+ * Fed by two taps:
+ * - `UtoMaster`'s `'utoFrame'` event, filtered to {@link UtoTag.LOG} (rm2mlog).
+ * - `AtCommandHandler`'s `'data'` event, which the handler emits for every decoded
+ *   chunk of debug-channel RX (its documented "raw monitoring" hook) — this is where
+ *   a DLO's live `printf` output arrives.
+ *
+ * The LOG payload layout is not modelled: the record's leading bytes are decoded
+ * best-effort (cp1252, then UTF-8) and cut at the first NUL. A payload that does not
+ * decode to text is stored as base64 in {@link DevLogRecord.raw} with a hex preview as
+ * its `text`, so nothing is silently dropped.
+ */
+declare class LogStream extends EventEmitter {
+    private readonly buffer;
+    private readonly capacity;
+    private readonly logFile;
+    private readonly logger;
+    private seq;
+    private disposers;
+    /** Serialises the JSONL appends so records cannot interleave mid-line. */
+    private writeChain;
+    /** `mkdir -p` of the log file's directory, done once instead of per record. */
+    private logDirReady;
+    constructor(opts?: {
+        capacity?: number;
+        logFile?: string;
+        logger?: Log.Logger;
+    });
+    /** Append a record, evict the oldest when full, emit `record` and mirror to `--log-file`. */
+    push(source: DevLogSource, text: string, raw?: Uint8Array): DevLogRecord;
+    private appendToFile;
+    /** Records after `since`, newest last, at most `limit` (`<= 0` ⇒ the default limit). */
+    since(since?: number, limit?: number): DevLogRecord[];
+    /** The highest sequence number handed out so far. */
+    get lastSeq(): number;
+    /** Tap rm2mlog frames off the UTO channel. */
+    attachUtoMaster(utoMaster: UtoMaster): void;
+    /**
+     * Tap the AT/debug channel RX, where a DLO's live `printf` output arrives.
+     *
+     * A `DebugMaster` parses the raw byte stream (console frames, the `!`/`?`/`~`/`$`
+     * level prefixes and the DLO file/line tags) instead of dumping unformatted chunks.
+     */
+    attachAtHandler(atHandler: AtCommandHandler): void;
+    /** Decode a device payload best-effort; keep the bytes when it is not text. */
+    private pushDecoded;
+    /** Detach the taps and await the pending JSONL appends, so no record is lost. */
+    dispose(): Promise<void>;
+}
+
 export declare namespace Manifest {
     /**
      * The source filename where the information is stored in
@@ -2771,6 +3243,16 @@ export declare namespace Manifest {
     export function validateRegistryAllowedApplications(allowedApplications: undefined | null | string | string[]): Promise<string | null>;
     export function validateApplicationIcon(cwd: URI, fs: LocalFS, manifest: Manifest.Manifest): Promise<void>;
     export function validateEngineSettings(manifest: Manifest.Manifest): void;
+    /**
+     * Compare two "engines.backend" version strings (format like "52v006").
+     * The major and minor parts are compared numerically so that values outside the zero-padded 2-digit
+     * major format (e.g. "100v001") are still ordered correctly. Values that do not match the format fall
+     * back to plain string ordering.
+     * @param a
+     * @param b
+     * @returns a negative number if a < b, 0 if equal, a positive number if a > b
+     */
+    export function compareBackendVersion(a: string, b: string): number;
     /**
      * Validate if the given apm part is used
      * @param cwd
@@ -2909,6 +3391,20 @@ export declare interface MyDatanetUserInfo {
     customers?: MyDatanetCustomer[];
 }
 
+/**
+ * A connected device: the UTO/AT primitives plus the raw transports, ready to use.
+ * Call `close()` exactly once when done to dispose the AtCommandHandler/UtoMaster and
+ * release the underlying transports.
+ */
+declare interface OpenDevice {
+    utoMaster: UtoMaster;
+    /** Only present when the debug interface was claimed (`needDebug`, the default). */
+    atHandler?: AtCommandHandler;
+    transports: DeviceTransports;
+    serial: string;
+    close(): Promise<void>;
+}
+
 /**
  * Packs the given directory into a deployable package using the specified configuration.
  *
@@ -5316,6 +5812,44 @@ export declare namespace Registry {
     } | {};
 }
 
+/** `GET /dev/status`'s `poll` section. */
+export declare interface StampPollerStatus {
+    intervalMs: number;
+    lastTick: number | null;
+    lastChange: number | null;
+    errors: number;
+    paused: boolean;
+}
+
+/**
+ * Opens the transports for a device given its serial number. The default (WebUSB) factory
+ * is used by {@link openDevice} unless a test/consumer supplies its own.
+ */
+export declare type TransportFactory = (serial: string, needDebug?: boolean) => Promise<DeviceTransports>;
+
+/**
+ * Upload result interface
+ */
+declare interface UploadResult {
+    success: boolean;
+    message: string;
+}
+
+/**
+ * Upload an AMX binary file to a USB device
+ * @param serialNumber - The serial number of the target device
+ * @param fileUri - The URI to the AMX file
+ * @param fs - The filesystem interface for file operations
+ * @param logger - The logger instance for output
+ * @param debugLog - Enable debug logging
+ * @param retryMs - Total ms budget to retry a transient device-open failure (see
+ *   {@link isTransientUsbOpenError}); `0` (the default) attempts once.
+ * @param transportFactory - Overrides how the transports are obtained (used by tests and by
+ *   consumers, e.g. the VS Code extension, running on their own injected transport).
+ * @returns Promise resolving to an UploadResult
+ */
+declare function uploadToDevice(serialNumber: string, fileUri: URI, fs: LocalFS, logger: Log.Logger, debugLog?: boolean, retryMs?: number, transportFactory?: TransportFactory): Promise<UploadResult>;
+
 declare function uriToMemFsPath(path: URI): string;
 
 declare interface XMLField {
@@ -5384,7 +5918,9 @@ declare namespace YamlPreCompiler {
             parsedYaml: null | Document_2.Parsed<ParsedNode, true>;
         };
         private yamlDocToDdeJson;
+        private reservedTopLevelKeys;
         private getRealContainerInformation;
+        private findContainerKeyRange;
         private findNextFreeContainer;
         private findPreviousUsedContainer;
         private createDDEJsonFields;