@v5x/serial 0.5.1 → 0.5.2

package/dist/Vex.d.ts

@@ -0,0 +1,235 @@
+import { type VexFirmwareVersion } from "./VexFirmwareVersion";
+import { type HostBoundPacket } from "./VexPacket";
+export declare const USER_PROG_CHUNK_SIZE = 4096;
+export declare const USER_FLASH_START = 50331648;
+export declare const USER_FLASH_SYS_CODE_START = 54525952;
+export declare const USER_FLASH_USR_CODE_START = 58720256;
+export declare const USER_FLASH_END = 134217728;
+export declare const USER_FLASH_MAX_FILE_SIZE = 2097152;
+export declare const USER_FLASH_START_B = 270532608;
+export declare const USER_FLASH_END_B = 272629760;
+export declare const USER_FLASH_START_C = 807403520;
+export declare const USER_FLASH_END_C = 822083584;
+export interface ISmartDeviceInfo {
+    port: number;
+    type: SmartDeviceType;
+    status: number;
+    betaversion: number;
+    version: number;
+    bootversion: number;
+}
+export interface IFileBasicInfo {
+    filename: string;
+    vendor: FileVendor;
+    loadAddress?: number;
+    size?: number;
+}
+export interface IFileMetadata {
+    loadAddress: number;
+    size: number;
+    crc32: number;
+    type: string;
+    timestamp: number;
+    version: VexFirmwareVersion;
+}
+export interface IFileHandle extends IFileBasicInfo, IFileMetadata {
+    loadAddress: number;
+    size: number;
+}
+export interface IFileEntry extends IFileMetadata {
+    index: number;
+    filename: string;
+}
+export interface IFileWriteRequest {
+    filename: string;
+    vendor?: FileVendor;
+    loadAddress?: number;
+    buf?: Uint8Array;
+    downloadTarget: FileDownloadTarget;
+    exttype?: string;
+    autoRun: boolean;
+    linkedFile?: IFileWriteRequest;
+}
+export interface IProgramInfo {
+    name: string;
+    binfile: string;
+    size: number;
+    time: Date;
+    slot: number;
+    requestedSlot: number;
+}
+export interface IPacketCallback {
+    callback: (data: HostBoundPacket | ArrayBuffer | AckType) => void;
+    timeout: ReturnType<typeof setTimeout>;
+    wantedCommandId: number | undefined;
+    wantedCommandExId: number | undefined;
+}
+export type DataArray = ArrayBuffer | Uint8Array;
+export type MatchMode = "driver" | "autonomous" | "disabled";
+export declare enum FileVendor {
+    USER = 1,
+    SYS = 15,
+    DEV1 = 16,
+    DEV2 = 24,
+    DEV3 = 32,
+    DEV4 = 40,
+    DEV5 = 48,
+    DEV6 = 56,
+    VEXVM = 64,
+    VEX = 240,
+    UNDEFINED = 241
+}
+export declare enum FileDownloadTarget {
+    FILE_TARGET_DDR = 0,
+    FILE_TARGET_QSPI = 1,
+    FILE_TARGET_CBUF = 2,
+    FILE_TARGET_VBUF = 3,
+    FILE_TARGET_DDRC = 4,
+    FILE_TARGET_DDRE = 5,
+    FILE_TARGET_FLASH = 6,
+    FILE_TARGET_RADIO = 7,
+    FILE_TARGET_A1 = 13,
+    FILE_TARGET_B1 = 14,
+    FILE_TARGET_B2 = 15
+}
+export declare enum FileInitAction {
+    WRITE = 1,
+    READ = 2
+}
+export declare enum FileInitOption {
+    NONE = 0,
+    OVERWRITE = 1
+}
+export declare enum FileLoadAction {
+    RUN = 0,
+    STOP = 128
+}
+export declare enum FileExitAction {
+    EXIT_NONE = 0,
+    EXIT_RUN = 1,
+    EXIT_HALT = 3
+}
+export declare enum RadioChannelType {
+    PIT = 0,
+    DOWNLOAD = 1
+}
+export type SlotNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export type ZerobaseSlotNumber = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export type PortNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21;
+export declare enum AckType {
+    CDC2_ACK = 118,
+    CDC2_NACK = 255,
+    CDC2_NACK_PACKET_CRC = 206,
+    CDC2_NACK_CMD_LENGTH = 208,
+    CDC2_NACK_SIZE = 209,
+    CDC2_NACK_CRC = 210,
+    CDC2_NACK_FILE = 211,
+    CDC2_NACK_INIT = 212,
+    CDC2_NACK_FUNC = 213,
+    CDC2_NACK_ALIGN = 214,
+    CDC2_NACK_ADDR = 215,
+    CDC2_NACK_INCOMPLETE = 216,
+    CDC2_NACK_DIR_INDEX = 217,
+    CDC2_NACK_MAX_USER_FILES = 218,
+    CDC2_NACK_FILE_EXISTS = 219,
+    CDC2_NACK_FILE_SYS_FULL = 220,
+    TIMEOUT = 256,
+    WRITE_ERROR = 257
+}
+export declare enum SmartDeviceType {
+    EMPTY = 0,
+    V5_POWER = 1,
+    MOTOR = 2,
+    LED = 3,
+    ABS_ENCODER_SENSOR = 4,
+    CR_MOTOR = 5,
+    IMU_SENSOR = 6,
+    DISTANCE_SENSOR = 7,
+    RADIO_SENSOR = 8,
+    CONTROLLER = 9,
+    BRAIN = 10,
+    VISION_SENSOR = 11,
+    ADI = 12,
+    PARTNER_CONTROLLER = 13,
+    BATTERY = 14,
+    SOL = 15,
+    OPTICAL_SENSOR = 16,
+    MAGNET = 17,
+    GPS_SENSOR = 20,
+    UNDEFINED_SENSOR = 255
+}
+export declare enum SerialDeviceType {
+    V5_BRAIN = 1281,
+    V5_BRAIN_DFU = 1282,
+    V5_CONTROLLER = 1283,
+    XILINX = 256,
+    IQ_BRAIN = 2,
+    IQ_BRAIN2 = 3,
+    IQ_BRAIN_DFU = 255,
+    IQ2_BRAIN = 512,
+    IQ2_BRAIN_DFU = 527,
+    IQ2_CONTROLLER = 528,
+    IQ2_CONTROLLER_DFU = 543,
+    EXP_BRAIN = 1536,
+    EXP_BRAIN_DFU = 1551,
+    EXP_CONTROLLER = 1552,
+    EXP_CONTROLLER_DFU = 1567,
+    PIXY = 61440,
+    PIXY_DFU = 12,
+    VEXCAM = 1287,
+    VEXCAM_DFU = 1288,
+    SENSOR_TEST = 1535,
+    CORTEX_PROGCBL = 10,
+    CORTEX_BRAIN = 11,
+    CORTEX_JOYSTK = 12,
+    VEXNET_KEY_20 = 7,
+    VEXNET_KEY_10 = 9587,
+    PROLIFIC = 8963
+}
+/**
+ * found from {@link https://gist.github.com/meisZWFLZ/9ebdd694060137b44959ff7ac80ff4e8 gist}
+ * @see {@link https://drive.google.com/drive/folders/11pSNKakbXp7hOYBQ3HNwprFaLalnXOgR screen images}
+ */
+export declare enum SelectDashScreen {
+    HOME = 0,
+    BATTERY = 1,
+    LED = 3,
+    MATCH_CONFIG = 4,
+    MATCH_CONFIG_MORE = 5,
+    WIRING = 6,
+    RADIO = 8,
+    BRAIN = 10,
+    RUN_PROGRAM = 13,
+    DRIVE_PROGRAM_CONTROL_LEFT_MAPPING = 14,
+    DRIVE_PROGRAM_MENU = 15,
+    DEVICES = 16,
+    USER_PROGRAM_FOLDER = 17,
+    VEX_PROGRAM_FOLDER = 18,
+    SETTINGS = 19,
+    /** theres some scary looking stuff in here */
+    SCARY_CONFIGURATION = 20,
+    LANGUAGE = 21,
+    DRIVE_MOTOR_CONFIG = 22,
+    PROGRAM_MENU = 24,
+    SHUTDOWN = 25,
+    CONTROLLER_2_MAPPING = 26,
+    /** theres some even more scary looking stuff in here */
+    SCARY_CONFIGURATION_MORE = 27,
+    /** maybe this is scarier.. */
+    CONFIRM_XX = 28,
+    CONTROLLER_1_MAPPING = 29,
+    DRIVE_PROGRAM_CONTROL_DUAL_MAPPING = 30,
+    DRIVE_PROGRAM_CONTROL_SPLIT_MAPPING = 31,
+    DRIVE_PROGRAM_CONTROL_RIGHT_MAPPING = 32,
+    /** thats such a bad name */
+    MATCH_2_4_PLAYERS = 33,
+    EVENT_LOG = 34,
+    USER_PROGRAM_WIRING = 40,
+    CLAWBOT_PROGRAM_MENU = 41,
+    /** aka regulatory */
+    ABOUT = 42,
+    LANGUAGE_MORE = 43,
+    OBJECT_COLOR = 45,
+    SIGNATURE_ID = 46,
+    LOG_DATA = 47
+}

package/dist/VexCRC.d.ts

@@ -0,0 +1,19 @@
+export declare class CrcGenerator {
+    crc16Table: Uint32Array;
+    crc32Table: Uint32Array;
+    static POLYNOMIAL_CRC32: number;
+    static POLYNOMIAL_CRC16: number;
+    constructor();
+    /**
+     * Calculate CRC16 for buffer
+     */
+    crc16(buf: Uint8Array, initValue: number): number;
+    /**
+     * Generate CRC32 reverse table
+     */
+    crc32GenTable(): void;
+    /**
+     * Calculate CRC32 for buffer
+     */
+    crc32(buf: Uint8Array, initValue: number): number;
+}

package/dist/VexConnection.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="dom-serial" />
+import { AckType, FileDownloadTarget, type IFileBasicInfo, type IFileWriteRequest, type IPacketCallback, type MatchMode, type SlotNumber, type SelectDashScreen } from "./Vex";
+import { VexEventTarget } from "./VexEvent";
+import { type ProgramIniConfig } from "./VexIniConfig";
+import { MatchStatusReplyD2HPacket, DeviceBoundPacket, MatchModeReplyD2HPacket, GetSystemStatusReplyD2HPacket, type HostBoundPacket, Query1ReplyD2HPacket, LoadFileActionReplyD2HPacket, GetSystemFlagsReplyD2HPacket, GetRadioStatusReplyD2HPacket, GetDeviceStatusReplyD2HPacket, SendDashTouchReplyD2HPacket, type SelectDashReplyD2HPacket } from "./VexPacket";
+import { type VexFirmwareVersion } from "./VexFirmwareVersion";
+/**
+ * A connection to a V5 device.
+ * Emit events: connected, disconnected
+ */
+export declare class VexSerialConnection extends VexEventTarget {
+    filters: SerialPortFilter[];
+    writer: WritableStreamDefaultWriter<unknown> | undefined;
+    reader: ReadableStreamDefaultReader<unknown> | undefined;
+    port: SerialPort | undefined;
+    serial: Serial;
+    callbacksQueue: IPacketCallback[];
+    get isConnected(): boolean;
+    constructor(serial: Serial);
+    close(): Promise<void>;
+    open(use?: number | undefined, askUser?: boolean): Promise<boolean | undefined>;
+    writeData(rawData: DeviceBoundPacket | Uint8Array, resolve: (data: HostBoundPacket | ArrayBuffer | AckType) => void, timeout?: number): void;
+    writeDataAsync(rawData: DeviceBoundPacket | Uint8Array, timeout?: number): Promise<HostBoundPacket | ArrayBuffer | AckType>;
+    protected readData(cache: Uint8Array, expectedSize: number): Promise<Uint8Array>;
+    protected startReader(): Promise<void>;
+    query1(): Promise<Query1ReplyD2HPacket | null>;
+    getSystemVersion(): Promise<VexFirmwareVersion | null>;
+}
+export declare class V5SerialConnection extends VexSerialConnection {
+    filters: SerialPortFilter[];
+    getDeviceStatus(): Promise<GetDeviceStatusReplyD2HPacket | null>;
+    getRadioStatus(): Promise<GetRadioStatusReplyD2HPacket | null>;
+    getSystemFlags(): Promise<GetSystemFlagsReplyD2HPacket | null>;
+    getSystemStatus(timeout?: number): Promise<GetSystemStatusReplyD2HPacket | null>;
+    getMatchStatus(): Promise<MatchStatusReplyD2HPacket | null>;
+    uploadProgramToDevice(iniConfig: ProgramIniConfig, binFileBuf: Uint8Array, coldFileBuf: Uint8Array | undefined, progressCallback: (state: string, current: number, total: number) => void): Promise<boolean | undefined>;
+    downloadFileToHost(request: IFileBasicInfo, downloadTarget?: FileDownloadTarget, progressCallback?: (current: number, total: number) => void): Promise<Uint8Array>;
+    uploadFileToDevice(request: IFileWriteRequest, progressCallback?: (current: number, total: number) => void): Promise<boolean>;
+    setMatchMode(mode: MatchMode): Promise<MatchModeReplyD2HPacket | null>;
+    loadProgram(value: SlotNumber | string): Promise<LoadFileActionReplyD2HPacket | null>;
+    stopProgram(): Promise<LoadFileActionReplyD2HPacket | null>;
+    mockTouch(x: number, y: number, press: boolean): Promise<SendDashTouchReplyD2HPacket | null>;
+    /** @param port untested */
+    openScreen(screen: number | SelectDashScreen, port: number): Promise<SelectDashReplyD2HPacket | null>;
+}

package/dist/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 {};

package/dist/VexEvent.d.ts

@@ -0,0 +1,16 @@
+export declare class VexEventEmitter {
+    handlerMap: Map<string | symbol, Array<(...args: unknown[]) => void>>;
+    constructor();
+    on(eventName: string | symbol, listener: (...args: unknown[]) => void): void;
+    remove(eventName: string | symbol, listener: (...args: unknown[]) => void): void;
+    emit(eventName: string | symbol, data: unknown): void;
+    clearListeners(): void;
+}
+export declare class VexEventTarget {
+    emitter: VexEventEmitter;
+    constructor();
+    emit(eventName: string | symbol, data: unknown): void;
+    on(eventName: string | symbol, listener: (...args: unknown[]) => void): void;
+    remove(eventName: string | symbol, listener: (...args: unknown[]) => void): void;
+    clearListeners(): void;
+}

package/dist/VexFirmwareVersion.d.ts

@@ -0,0 +1,55 @@
+/**
+ * This is a class to make it easier to handle passing the VEXos version
+ * information around in the application. This provides ways to get any
+ * form of the string representation and quickly compare versions.
+ */
+export declare class VexFirmwareVersion {
+    major: number;
+    minor: number;
+    build: number;
+    beta: number;
+    constructor(major: number, minor: number, build: number, beta: number);
+    /**
+     * Take a a string of MAJOR.MINOR.BUILD.bBETA and converts it to a
+     * VexFirmwareVersion instance
+     * @param version the string to process
+     * @returns a VexFirmwareVersion representing the provided string
+     */
+    static fromString(version: string): VexFirmwareVersion;
+    /**
+     * Take a a Uint8Array and converts it to a VexFirmwareVersion instance
+     * @param data the array to process
+     * @param offset the offset to start at
+     * @returns a VexFirmwareVersion representing the provided string
+     */
+    static fromUint8Array(data: Uint8Array, offset?: number, reverse?: boolean): VexFirmwareVersion;
+    static allZero(): VexFirmwareVersion;
+    /**
+     * Take a a string of MAJOR_MINOR_BUILD_BETA and converts it to a
+     * VexFirmwareVersion instance
+     * @param version the string to process
+     * @returns a VexFirmwareVersion representing the provided string
+     */
+    static fromCatalogString(version: string): VexFirmwareVersion;
+    isBeta(): boolean;
+    /**
+     * returns version as Uint Array
+     */
+    toUint8Array(reverse?: boolean): Uint8Array;
+    /**
+     * returns version as major.minor.build
+     */
+    toUserString(): string;
+    /**
+     * returns version as ${major}.${minor}.{build}.b${beta}
+     */
+    toInternalString(): string;
+    /**
+     * compares this version to the provided version.
+     * * if this < b: negative
+     * * if this = b: 0
+     * * if this > b: positive
+     * @param that the version to compare again
+     */
+    compare(that: VexFirmwareVersion): number;
+}

package/dist/VexIniConfig.d.ts

@@ -0,0 +1,27 @@
+import { type ZerobaseSlotNumber } from "./Vex";
+export declare class ProgramIniConfig {
+    baseName: string;
+    autorun: boolean;
+    project: {
+        version: string;
+        ide: string;
+        file: string;
+    };
+    program: {
+        version: string;
+        name: string;
+        slot: ZerobaseSlotNumber;
+        icon: string;
+        iconalt: string;
+        description: string;
+        date: string;
+        timezone: string;
+    };
+    config: Record<number, string>;
+    controller1: Record<string, string>;
+    controller2: Record<string, string>;
+    constructor();
+    setProgramDate(date: Date): void;
+    createIni(): string;
+    dec2(value: number): string;
+}