Types

export const DEFAULT_SERIAL_TIMEOUT_MS = 1000;

export const LogLevel = {
  None: 'None',
  Error: 'Error',
  Warn: 'Warn',
  Info: 'Info',
  Debug: 'Debug',
} as const;

export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];

export type SerialEvent =
  | { kind: 'data'; path: string; data: number[]; size: number }
  | { kind: 'urc'; path: string; line: string }
  | { kind: 'disconnect'; path: string; reason: string }
  | { kind: 'error'; path: string; message: string };

export type ByteSeq = string | number[] | Uint8Array;

export type ParserOptions =
  /** Split on a byte sequence (`@serialport/parser-delimiter`). Full buffer is emitted as a frame. */
  | { type: 'delimiter'; delimiter: ByteSeq; includeDelimiter?: boolean; maxBufferSize?: number }
  /** Split on `delimiter`, default `"\n"` (`@serialport/parser-readline`). */
  | {
      type: 'readline';
      delimiter?: ByteSeq;
      includeDelimiter?: boolean;
      maxBufferSize?: number;
      /** Node's string-rendering option: accepted and ignored (frames are decoded by `watch`). */
      encoding?: string;
    }
  /** Fixed-size frames of `length` bytes (`@serialport/parser-byte-length`). */
  | { type: 'byteLength'; length: number }
  /**
   * A frame ends after `intervalMs` (alias `interval`) of silence (`@serialport/parser-inter-byte-timeout`).
   * Give exactly one of `intervalMs` / `interval`.
   */
  | { type: 'interByteTimeout'; intervalMs: number; interval?: never; maxBufferSize?: number }
  | { type: 'interByteTimeout'; interval: number; intervalMs?: never; maxBufferSize?: number }
  /**
   * Delimiter + little-endian length field (`@serialport/parser-packet-length`).
   * Defaults: delimiter 0xaa, delimiterBytes 1, packetOverhead 2, lengthBytes 1,
   * lengthOffset 1, maxLen 0xff, maxBufferSize 65536 (a packet that cannot complete
   * within it is emitted as a frame).
   */
  | {
      type: 'packetLength';
      delimiter?: number | number[];
      delimiterBytes?: number;
      packetOverhead?: number;
      lengthBytes?: number;
      lengthOffset?: number;
      maxLen?: number;
      maxBufferSize?: number;
    }
  /** Drop everything until `delimiter`, then pass data through (`@serialport/parser-ready`). */
  | { type: 'ready'; delimiter: ByteSeq }
  /** Split UTF-8 text on a regular expression (Rust `regex-lite` syntax, not a JS `RegExp`). */
  | {
      type: 'regex';
      regex: string;
      maxBufferSize?: number;
      /** Node's string-rendering option: accepted and ignored. */
      encoding?: string;
    }
  /** Frames between a start and an end marker (`@serialport/parser-start-end`). */
  | {
      type: 'startEnd';
      startDelimiter: ByteSeq;
      endDelimiter: ByteSeq;
      includeStartDelimiter?: boolean;
      includeEndDelimiter?: boolean;
      maxBufferSize?: number;
    }
  /** SLIP (RFC 1055) decoder (`@serialport/parser-slip-encoder` `SlipDecoder`); bytes default to RFC values. */
  | {
      type: 'slip';
      start?: number;
      esc?: number;
      end?: number;
      escStart?: number;
      escEnd?: number;
      escEsc?: number;
    }
  /** ccTalk frames, length in byte 1 (`@serialport/parser-cctalk`). A partial frame is dropped after `maxDelayMs` (default 50, 0 = never). */
  | { type: 'ccTalk'; maxDelayMs?: number };

export type PortListEvent =
  | { kind: 'snapshot'; ports: Record<string, PortInfo> }
  | { kind: 'added'; path: string; info: PortInfo }
  | { kind: 'removed'; path: string };

export type BaudRate =
  | 110
  | 300
  | 600
  | 1200
  | 2400
  | 4800
  | 9600
  | 14400
  | 19200
  | 38400
  | 57600
  | 115200
  | 230400
  | 460800
  | 921600;

export type RxPrepareMode = 'drain' | 'purge' | 'none';

export type AtResultFormat = 'verbose' | 'numeric';

export type ExchangeCompletionMode = 'atFinalLine' | 'atIntermediate' | 'substring';

export type AtParseStatus = 'ok' | 'error' | 'cme' | 'cms' | 'unknown';

export type ExchangeMatch =
  | 'ok'
  | 'error'
  | 'idle'
  | 'noCarrier'
  | 'busy'
  | 'noAnswer'
  | 'noDialtone'
  | 'sendOk'
  | 'sendFail'
  /**
   * Verbose texts (`AT+CMEE=2`) are mapped to their numeric `code` (`"SIM busy"` → 14);
   * `code` is `null` only for text the parser does not know.
   */
  | { cmeError: { code?: number | null } }
  /** Same shape as `cmeError`, for `+CMS ERROR`. */
  | { cmsError: { code?: number | null } }
  | { intermediate: { line: string } }
  | { substring: { term: string } };