@v5x/serial 0.5.0 → 0.5.2

package/dts/VexDevice.d.ts

@@ -0,0 +1,177 @@
+/// <reference types="dom-serial" />
+import { type MatchMode, SerialDeviceType, type ISmartDeviceInfo, SmartDeviceType, FileVendor, type IProgramInfo, type IFileHandle, FileDownloadTarget, type IFileBasicInfo, type IFileWriteRequest, RadioChannelType } from "./Vex";
+import { V5SerialConnection } from "./VexConnection";
+import { VexEventTarget } from "./VexEvent";
+import { VexFirmwareVersion } from "./VexFirmwareVersion";
+import { type ProgramIniConfig } from "./VexIniConfig";
+export declare function downloadFileFromInternet(link: string): Promise<ArrayBuffer>;
+export declare function sleepUntilAsync(f: () => Promise<boolean>, timeout: number, interval?: number): Promise<boolean>;
+export declare function sleepUntil(f: () => boolean, timeout: number, interval?: number): Promise<boolean>;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare abstract class VexSerialDevice extends VexEventTarget {
+    connection: V5SerialConnection | undefined;
+    defaultSerial: Serial;
+    get isConnected(): boolean;
+    get deviceType(): SerialDeviceType | undefined;
+    constructor(defaultSerial: Serial);
+    abstract connect(conn?: V5SerialConnection): Promise<boolean>;
+    abstract disconnect(): void;
+}
+declare class V5SerialDeviceState {
+    _instance: V5SerialDevice;
+    _isFileTransferring: boolean;
+    brain: {
+        activeProgram: number;
+        battery: {
+            batteryPercent: number;
+            isCharging: boolean;
+        };
+        button: {
+            isPressed: boolean;
+            isDoublePressed: boolean;
+        };
+        cpu0Version: VexFirmwareVersion;
+        cpu1Version: VexFirmwareVersion;
+        isAvailable: boolean;
+        settings: {
+            isScreenReversed: boolean;
+            isWhiteTheme: boolean;
+            usingLanguage: number;
+        };
+        systemVersion: VexFirmwareVersion;
+        uniqueId: number;
+    };
+    controllers: ({
+        battery: number;
+        isAvailable: boolean;
+        isCharging: boolean;
+    } | {
+        battery: number;
+        isAvailable: boolean;
+        isCharging?: undefined;
+    })[];
+    devices: Array<ISmartDeviceInfo | undefined>;
+    isFieldControllerConnected: boolean;
+    matchMode: MatchMode;
+    radio: {
+        channel: number;
+        isAvailable: boolean;
+        isConnected: boolean;
+        isVexNet: boolean;
+        isRadioData: boolean;
+        latency: number;
+        signalQuality: number;
+        signalStrength: number;
+    };
+    constructor(instance: V5SerialDevice);
+}
+export declare class V5Brain {
+    private readonly state;
+    constructor(state: V5SerialDeviceState);
+    get isRunningProgram(): boolean;
+    get activeProgram(): number;
+    set activeProgram(value: number);
+    get battery(): V5Battery;
+    get button(): V5BrainButton;
+    get cpu0Version(): VexFirmwareVersion;
+    get cpu1Version(): VexFirmwareVersion;
+    get isAvailable(): boolean;
+    get settings(): V5BrainSettings;
+    get systemVersion(): VexFirmwareVersion;
+    get uniqueId(): number;
+    getValue(key: string): Promise<string | undefined>;
+    setValue(key: string, value: string): Promise<boolean>;
+    listFiles(vendor?: FileVendor): Promise<IFileHandle[] | undefined>;
+    listProgram(): Promise<IProgramInfo[] | undefined>;
+    readFile(request: IFileBasicInfo | string, downloadTarget?: FileDownloadTarget, progressCallback?: (current: number, total: number) => void): Promise<Uint8Array | undefined>;
+    removeFile(request: IFileBasicInfo | string): Promise<boolean | undefined>;
+    removeAllFiles(): Promise<boolean | undefined>;
+    uploadFirmware(publicUrl?: string, usingVersion?: string, progressCallback?: (state: string, current: number, total: number) => void): Promise<boolean | undefined>;
+    uploadProgram(iniConfig: ProgramIniConfig, binFileBuf: Uint8Array, coldFileBuf: Uint8Array | undefined, progressCallback: (state: string, current: number, total: number) => void): Promise<boolean | undefined>;
+    writeFile(request: IFileWriteRequest, progressCallback?: (current: number, total: number) => void): Promise<boolean | undefined>;
+    /**
+     *
+     * @param progressCallback Informs the progress of the download.
+     * @returns array of bytes where each pixel is represented by 3 consecutive bytes (rgb).
+     * This array's length is 272 width * 480 height * 3 channels = 391680 bytes.
+     */
+    captureScreen(progressCallback?: (current: number, total: number) => void): Promise<Uint8Array | undefined>;
+}
+export declare class V5Battery {
+    private readonly state;
+    constructor(state: V5SerialDeviceState);
+    get batteryPercent(): number;
+    get isCharging(): boolean;
+}
+export declare class V5BrainButton {
+    private readonly state;
+    constructor(state: V5SerialDeviceState);
+    get isPressed(): boolean;
+    get isDoublePressed(): boolean;
+}
+export declare class V5BrainSettings {
+    private readonly state;
+    constructor(state: V5SerialDeviceState);
+    get isScreenReversed(): boolean;
+    get isWhiteTheme(): boolean;
+    get usingLanguage(): number;
+}
+export declare class V5Controller {
+    private readonly state;
+    private readonly controllerIndex;
+    constructor(state: V5SerialDeviceState, controllerIndex: number);
+    get batteryPercent(): number;
+    get isMasterController(): boolean;
+    get isAvailable(): boolean;
+    get isCharging(): boolean | undefined;
+}
+export declare class V5SmartDevice {
+    private readonly state;
+    private readonly deviceIndex;
+    constructor(state: V5SerialDeviceState, index: number);
+    protected getDeviceInfo(): ISmartDeviceInfo | undefined;
+    get isAvailable(): boolean;
+    get port(): number;
+    get type(): SmartDeviceType;
+    get version(): number;
+}
+export declare class V5Radio {
+    private readonly state;
+    constructor(state: V5SerialDeviceState);
+    get channel(): number;
+    get isAvailable(): boolean;
+    get isConnected(): boolean;
+    get isVexNet(): boolean;
+    get isRadioData(): boolean;
+    get latency(): number;
+    changeChannel(channel: RadioChannelType): Promise<boolean>;
+}
+export declare class V5SerialDevice extends VexSerialDevice {
+    autoReconnect: boolean;
+    autoRefresh: boolean;
+    pauseRefreshOnFileTransfer: boolean;
+    protected _isReconnecting: boolean;
+    private _refreshInterval;
+    state: V5SerialDeviceState;
+    constructor(defaultSerial: Serial);
+    get isV5Controller(): boolean;
+    get brain(): V5Brain;
+    get controllers(): [V5Controller, V5Controller];
+    get devices(): V5SmartDevice[];
+    get isFieldControllerConnected(): boolean;
+    get matchMode(): MatchMode;
+    set matchMode(value: MatchMode);
+    get radio(): V5Radio;
+    mockTouch(x: number, y: number, press: boolean): Promise<boolean>;
+    connect(conn?: V5SerialConnection): Promise<boolean>;
+    disconnect(): Promise<void>;
+    dispose(): Promise<void>;
+    /**
+     * @param timeout defaults to 0. If timeout is 0, then it will attempt to reconnect forever
+     * @returns
+     */
+    reconnect(timeout?: number): Promise<boolean>;
+    private doAfterConnect;
+    refresh(): Promise<boolean>;
+}
+export {};