brilliant-msg 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+export { BrilliantMsg, StdLua } from './brilliant-msg';
+export { AsyncQueue } from './async-queue';
+export { TxPlainText } from './tx/plain-text';
+export type { TxPlainTextOptions } from './tx/plain-text';
+export { TxCaptureSettings } from './tx/capture-settings';
+export type { TxCaptureSettingsOptions } from './tx/capture-settings';
+export { TxCode } from './tx/code';
+export type { TxCodeOptions } from './tx/code';
+export { TxImageSpriteBlock } from './tx/image-sprite-block';
+export type { TxImageSpriteBlockOptions } from './tx/image-sprite-block';
+export { TxManualExpSettings } from './tx/manual-exp-settings';
+export type { TxManualExpSettingsOptions } from './tx/manual-exp-settings';
+export { TxAutoExpSettings } from './tx/auto-exp-settings';
+export type { TxAutoExpSettingsOptions } from './tx/auto-exp-settings';
+export { TxSprite } from './tx/sprite';
+export type { TxSpriteOptions } from './tx/sprite';
+export { TxSpriteCoords } from './tx/sprite-coords';
+export type { TxSpriteCoordsOptions } from './tx/sprite-coords';
+export { TxTextSpriteBlock } from './tx/text-sprite-block';
+export type { TxTextSpriteBlockOptions } from './tx/text-sprite-block';
+export { RxAudio, RxAudioBitDepth, RxAudioSampleRate } from './rx/audio';
+export type { RxAudioOptions } from './rx/audio';
+export { RxIMU, IMUData } from './rx/imu';
+export type { RxIMUOptions, IMURawData } from './rx/imu';
+export { RxMeteringData } from './rx/metering-data';
+export type { RxMeteringDataOptions, MeteringData } from './rx/metering-data';
+export { RxAutoExpResult } from './rx/auto-exp-result';
+export type { BrightnessDetails, BrightnessData, AutoExpResultData, RxAutoExpResultOptions } from './rx/auto-exp-result';
+export { RxPhoto } from './rx/photo';
+export type { RxPhotoOptions, JpegQuality } from './rx/photo';
+export { RxTap } from './rx/tap';
+export type { RxTapOptions } from './rx/tap';
+export { RxClick, ClickType } from './rx/click';
+export type { RxClickOptions } from './rx/click';
+export { TxTextPage, RectangularTextLayout, CircularTextLayout, PageData } from './tx/text-page';
+export type { TextLayout, TxTextPageOptions } from './tx/text-page';

package/dist/rx/audio.d.ts

@@ -0,0 +1,129 @@
+import { BrilliantMsg } from '../brilliant-msg';
+import { AsyncQueue } from '../async-queue';
+/**
+ * Defines the supported audio sample rates.
+ */
+export declare enum RxAudioSampleRate {
+    /** Sample rate of 8000 Hz. */
+    SAMPLE_RATE_8KHZ = 8000,
+    /** Sample rate of 16000 Hz. */
+    SAMPLE_RATE_16KHZ = 16000
+}
+/**
+ * Defines the supported audio bit depths.
+ */
+export declare enum RxAudioBitDepth {
+    /** Bit depth of 8 bits per sample. */
+    BIT_DEPTH_8 = 8,
+    /** Bit depth of 16 bits per sample. */
+    BIT_DEPTH_16 = 16
+}
+/**
+ * Configuration options for the RxAudio class.
+ */
+export interface RxAudioOptions {
+    /** Optional msgCode indicating a non-final audio chunk. Defaults to 0x05. */
+    nonFinalChunkMsgCode?: number;
+    /** Optional msgCode indicating the final audio chunk. Defaults to 0x06. */
+    finalChunkMsgCode?: number;
+    /** Optional msgCode to enable streaming mode. Defaults to false (clip mode). */
+    streaming?: boolean;
+    /** Optional audio sample rate. Defaults to 8000 Hz. */
+    sampleRate?: RxAudioSampleRate;
+    /** Optional audio bit depth. Defaults to 8 bits. */
+    bitDepth?: RxAudioBitDepth;
+}
+/**
+ * RxAudio class handles audio data streaming and processing.
+ * It can operate in two modes: streaming and single-clip mode.
+ * In streaming mode, it processes audio data in real-time.
+ * In single-clip mode, it accumulates audio data until a final chunk is received.
+ * The class provides methods to attach and detach from a BrilliantMsg instance,
+ * and to convert PCM data to WAV format.
+ * Depending on how it is constructed, it will return samples as either
+ * signed 8 or signed 16 bit integers, and the source bit depth in Lua should match.
+ */
+export declare class RxAudio {
+    private nonFinalChunkMsgCode;
+    private finalChunkMsgCode;
+    private streaming;
+    private bitDepth;
+    private sampleRate;
+    /**
+     * Asynchronous queue for processed audio data chunks.
+     * Each chunk is an Int8Array or Int16Array, or null to signal the end of a stream/clip.
+     */
+    queue: AsyncQueue<Int8Array | Int16Array | null> | null;
+    /** @internal Buffer to accumulate audio chunks in non-streaming (clip) mode. */
+    private _audioBuffer;
+    /**
+     * Constructs an instance of the RxAudio class.
+     * @param options Configuration options for the audio handler.
+     */
+    constructor(options?: RxAudioOptions);
+    /**
+     * @internal Concatenates all audio chunks in the `_audioBuffer`.
+     * Used in non-streaming mode to assemble the complete audio clip.
+     * @returns A single Uint8Array containing all accumulated audio data.
+     */
+    private concatenateAudioData;
+    /**
+     * Handles incoming raw audio data chunks.
+     * This method is typically called by a `BrilliantMsg` instance when new audio data is received.
+     * It processes the data based on the configured mode (streaming or clip) and bit depth,
+     * then places the processed audio chunk (Int8Array or Int16Array) onto the `queue`.
+     * A null is placed on the queue to signal the end of a stream or clip.
+     * @param data A Uint8Array containing the raw audio data, prefixed with a msgCode byte.
+     */
+    handleData(data: Uint8Array): void;
+    /**
+     * Attaches this RxAudio instance to a BrilliantMsg object to receive audio data.
+     * It initializes the audio queue and registers a handler for incoming data.
+     * @param frame The BrilliantMsg instance to attach to.
+     * @returns A Promise that resolves to the `AsyncQueue` where audio chunks will be placed.
+     */
+    attach(frame: BrilliantMsg): Promise<AsyncQueue<Int8Array | Int16Array | null>>;
+    /**
+     * Detaches this RxAudio instance from a BrilliantMsg object.
+     * It unregisters the data handler and clears the audio queue.
+     * @param frame The BrilliantMsg instance to detach from.
+     */
+    detach(frame: BrilliantMsg): void;
+    /**
+     * @internal Helper function to write a string to a DataView.
+     * Used for constructing WAV file headers.
+     * @param view The DataView to write to.
+     * @param offset The offset at which to start writing.
+     * @param str The string to write.
+     */
+    private static writeString;
+    /**
+     * Converts raw PCM audio data to WAV file format (as a Uint8Array).
+     * @param pcmData The raw PCM data. For 8-bit, assumes signed samples that will be converted to unsigned for WAV.
+     * @param sampleRate The sample rate of the audio (e.g., 8000 Hz). Defaults to 8000.
+     * @param bitsPerSample The number of bits per sample (e.g., 8 or 16). Defaults to 8.
+     * @param channels The number of audio channels (e.g., 1 for mono). Defaults to 1.
+     * @returns A Uint8Array containing the WAV file data.
+     */
+    static toWavBytes(pcmData: Uint8Array, sampleRate?: number, bitsPerSample?: number, channels?: number): Uint8Array;
+    /**
+     * Converts signed 8-bit PCM data (provided as a Uint8Array) to a Float32Array.
+     * The samples are scaled to the range [-1.0, 1.0].
+     * Note: Assumes input samples are signed bytes. Reinterprets Uint8Array as Int8Array.
+     * Samples are scaled by 1/64 (instead of 1/128) and clamped to [-1.0, 1.0]
+     * to account for typical microphone dynamic range usage.
+     * @param pcmData The Uint8Array containing signed 8-bit PCM data.
+     * @returns A Float32Array with samples scaled to [-1.0, 1.0].
+     */
+    static pcm8BitToFloat32(pcmData: Uint8Array): Float32Array<ArrayBuffer>;
+    /**
+     * Converts signed 16-bit PCM data (provided as a Uint8Array) to a Float32Array.
+     * The samples are scaled to the range [-1.0, 1.0].
+     * Note: Assumes input Uint8Array contains little-endian signed 16-bit samples.
+     * Samples are scaled by 1/16384 (instead of 1/32768) and clamped to [-1.0, 1.0]
+     * to account for typical microphone dynamic range usage.
+     * @param pcmData The Uint8Array containing signed 16-bit PCM data (little-endian).
+     * @returns A Float32Array with samples scaled to [-1.0, 1.0].
+     */
+    static pcm16BitToFloat32(pcmData: Uint8Array): Float32Array<ArrayBuffer>;
+}

package/dist/rx/auto-exp-result.d.ts

@@ -0,0 +1,85 @@
+import { BrilliantMsg } from '../brilliant-msg';
+import { AsyncQueue } from '../async-queue';
+/**
+ * Interface for the detailed brightness metrics (matrix or spot).
+ */
+export interface BrightnessDetails {
+    /** Red channel brightness component. */
+    r: number;
+    /** Green channel brightness component. */
+    g: number;
+    /** Blue channel brightness component. */
+    b: number;
+    /** Average brightness across R, G, B channels. */
+    average: number;
+}
+/**
+ * Interface for the overall brightness data structure.
+ */
+export interface BrightnessData {
+    /** Center-weighted average brightness of the scene. */
+    center_weighted_average: number;
+    /** Overall scene brightness. */
+    scene: number;
+    /** Detailed brightness metrics using matrix metering. */
+    matrix: BrightnessDetails;
+    /** Detailed brightness metrics using spot metering. */
+    spot: BrightnessDetails;
+}
+/**
+ * Interface for the structured auto exposure result data.
+ */
+export interface AutoExpResultData {
+    /** The error value from the auto exposure algorithm. */
+    error: number;
+    /** The calculated shutter speed (exposure time). */
+    shutter: number;
+    /** The calculated analog gain. */
+    analog_gain: number;
+    /** The red channel gain. */
+    red_gain: number;
+    /** The green channel gain. */
+    green_gain: number;
+    /** The blue channel gain. */
+    blue_gain: number;
+    /** Detailed brightness data used for auto exposure. */
+    brightness: BrightnessData;
+}
+/**
+ * Options for RxAutoExpResult constructor.
+ */
+export interface RxAutoExpResultOptions {
+    /** Optional message code to identify auto exposure result packets. Defaults to 0x11. */
+    msgCode?: number;
+}
+/**
+ * RxAutoExpResult class handles processing of auto exposure result data packets.
+ */
+export declare class RxAutoExpResult {
+    private msgCode;
+    /** Asynchronous queue for received auto exposure result data. Null if not attached. */
+    queue: AsyncQueue<AutoExpResultData | null> | null;
+    /**
+     * Initialize receive handler for processing auto exposure result data.
+     * @param options Configuration options for the handler.
+     * Includes `msgCode` (default: 0x11)
+     */
+    constructor(options?: RxAutoExpResultOptions);
+    /**
+     * Process incoming auto exposure result data packets.
+     * @param data Uint8Array containing auto exposure result data with a msgCode byte prefix,
+     * followed by 16 little-endian floats (64 bytes).
+     */
+    handleData(data: Uint8Array): void;
+    /**
+     * Attach the receive handler to the Frame data response.
+     * @param frame The BrilliantMsg instance.
+     * @returns A promise that resolves to an AsyncQueue that will receive AutoExpResultData objects.
+     */
+    attach(frame: BrilliantMsg): Promise<AsyncQueue<AutoExpResultData | null>>;
+    /**
+     * Detach the receive handler from the Frame data response and clean up resources.
+     * @param frame The BrilliantMsg instance.
+     */
+    detach(frame: BrilliantMsg): void;
+}

package/dist/rx/click.d.ts

@@ -0,0 +1,50 @@
+import { BrilliantMsg } from '../brilliant-msg';
+import { AsyncQueue } from '../async-queue';
+/**
+ * Enum representing the types of tap/click detected by the Frame device.
+ */
+export declare enum ClickType {
+    /** A single tap/click. */
+    SINGLE = 1,
+    /** A double tap/click. */
+    DOUBLE = 2,
+    /** A long press. */
+    LONG = 3
+}
+/**
+ * Options for RxClick constructor.
+ */
+export interface RxClickOptions {
+    /** Optional msgCode to identify click data packets. Defaults to 0x0B. */
+    clickFlag?: number;
+}
+/**
+ * RxClick handles incoming tap/click events from the Frame device.
+ * It processes raw BLE data and enqueues typed ClickType values.
+ */
+export declare class RxClick {
+    private clickFlag;
+    /** Asynchronous queue for received ClickType values. Null if not attached. */
+    queue: AsyncQueue<ClickType | null> | null;
+    /**
+     * Constructs an instance of the RxClick class.
+     * @param options Configuration options for the click handler.
+     */
+    constructor(options?: RxClickOptions);
+    /**
+     * Process incoming click data packets.
+     * @param data Uint8Array containing click data: [clickFlag, clickType].
+     */
+    handleData(data: Uint8Array): void;
+    /**
+     * Attach the click handler to the Frame data response.
+     * @param frame The BrilliantMsg instance.
+     * @returns A promise that resolves to an AsyncQueue that will receive ClickType values.
+     */
+    attach(frame: BrilliantMsg): Promise<AsyncQueue<ClickType | null>>;
+    /**
+     * Detach the click handler from the Frame data response and clean up resources.
+     * @param frame The BrilliantMsg instance.
+     */
+    detach(frame: BrilliantMsg): void;
+}

package/dist/rx/imu.d.ts

@@ -0,0 +1,77 @@
+import { BrilliantMsg } from '../brilliant-msg';
+import { AsyncQueue } from '../async-queue';
+/**
+ * Interface for raw IMU data.
+ */
+export interface IMURawData {
+    /** Raw compass data as a tuple: `[x, y, z]`. */
+    compass: [number, number, number];
+    /** Raw accelerometer data as a tuple: `[x, y, z]`. */
+    accel: [number, number, number];
+}
+/**
+ * Class for processed IMU data.
+ * Contains smoothed compass and accelerometer data, and optionally the raw data.
+ * Also provides calculated pitch and roll values.
+ */
+export declare class IMUData {
+    /** Smoothed compass data as a tuple: `[x, y, z]`. */
+    compass: [number, number, number];
+    /** Smoothed accelerometer data as a tuple: `[x, y, z]`. */
+    accel: [number, number, number];
+    /** Optional raw IMU data. */
+    raw?: IMURawData;
+    /**
+     * Constructs an instance of IMUData.
+     * @param compass Smoothed compass data `[x, y, z]`.
+     * @param accel Smoothed accelerometer data `[x, y, z]`.
+     * @param raw Optional raw IMU data.
+     */
+    constructor(compass: [number, number, number], accel: [number, number, number], raw?: IMURawData);
+    /** Calculated pitch in degrees. */
+    get pitch(): number;
+    /** Calculated roll in degrees. */
+    get roll(): number;
+}
+/**
+ * Options for RxIMU constructor.
+ */
+export interface RxIMUOptions {
+    /** Optional msgCode to identify IMU data packets. Defaults to 0x0A. */
+    msgCode?: number;
+    /** Optional number of samples to average for smoothing. Defaults to 1 (no smoothing). */
+    smoothingSamples?: number;
+}
+/**
+ * RxIMU class handles IMU data processing.
+ * It processes magnetometer and accelerometer data, providing smoothed values.
+ */
+export declare class RxIMU {
+    private msgCode;
+    private smoothingSamples;
+    /** Asynchronous queue for received IMUData objects. Null if not attached. */
+    queue: AsyncQueue<IMUData | null> | null;
+    private compassBuffer;
+    private accelBuffer;
+    /**
+     * Constructs an instance of the RxIMU class.
+     * @param options Configuration options for the IMU handler.
+     */
+    constructor(options?: RxIMUOptions);
+    /**
+     * Process incoming IMU data packets.
+     * @param data Uint8Array containing IMU data with msgCode byte prefix.
+     */
+    handleData(data: Uint8Array): void;
+    /**
+     * Attach the IMU handler to the Frame data response.
+     * @param frame The BrilliantMsg instance.
+     * @returns A promise that resolves to an AsyncQueue that will receive IMUData objects.
+     */
+    attach(frame: BrilliantMsg): Promise<AsyncQueue<IMUData | null>>;
+    /**
+     * Detach the IMU handler from the Frame data response and clean up resources.
+     * @param frame The BrilliantMsg instance.
+     */
+    detach(frame: BrilliantMsg): void;
+}

package/dist/rx/metering-data.d.ts

@@ -0,0 +1,56 @@
+import { BrilliantMsg } from '../brilliant-msg';
+import { AsyncQueue } from '../async-queue';
+/**
+ * Interface for the structured metering data.
+ */
+export interface MeteringData {
+    /** Spot metering red channel value. */
+    spot_r: number;
+    /** Spot metering green channel value. */
+    spot_g: number;
+    /** Spot metering blue channel value. */
+    spot_b: number;
+    /** Matrix metering red channel value. */
+    matrix_r: number;
+    /** Matrix metering green channel value. */
+    matrix_g: number;
+    /** Matrix metering blue channel value. */
+    matrix_b: number;
+}
+/**
+ * Options for RxMeteringData constructor.
+ */
+export interface RxMeteringDataOptions {
+    /** Optional message code to identify metering data packets. Defaults to 0x12. */
+    msgCode?: number;
+}
+/**
+ * RxMeteringData class handles processing of metering data packets.
+ */
+export declare class RxMeteringData {
+    private msgCode;
+    /** Asynchronous queue for received MeteringData objects. Null if not attached. */
+    queue: AsyncQueue<MeteringData | null> | null;
+    /**
+     * Constructs an instance of the RxMeteringData class.
+     * @param options Configuration options for the metering data handler.
+     */
+    constructor(options?: RxMeteringDataOptions);
+    /**
+     * Process incoming metering data packets.
+     * @param data Uint8Array containing metering data with a msgCode byte prefix,
+     * followed by 6 unsigned bytes (spot r,g,b, matrix r,g,b).
+     */
+    handleData(data: Uint8Array): void;
+    /**
+     * Attach the receive handler to the Frame data response.
+     * @param frame The BrilliantMsg instance.
+     * @returns A promise that resolves to an AsyncQueue that will receive MeteringData objects.
+     */
+    attach(frame: BrilliantMsg): Promise<AsyncQueue<MeteringData | null>>;
+    /**
+     * Detach the receive handler from the Frame data response and clean up resources.
+     * @param frame The BrilliantMsg instance.
+     */
+    detach(frame: BrilliantMsg): void;
+}

package/dist/rx/photo.d.ts

@@ -0,0 +1,81 @@
+import { BrilliantMsg } from '../brilliant-msg';
+import { AsyncQueue } from '../async-queue';
+/** Defines the available JPEG quality settings. */
+export type JpegQuality = 'VERY_LOW' | 'LOW' | 'MEDIUM' | 'HIGH' | 'VERY_HIGH';
+/**
+ * Configuration options for the RxPhoto class.
+ */
+export interface RxPhotoOptions {
+    /** Optional msgCode indicating a non-final photo data chunk. Defaults to 0x07. */
+    nonFinalChunkMsgCode?: number;
+    /** Optional msgCode indicating the final photo data chunk. Defaults to 0x08. */
+    finalChunkMsgCode?: number;
+    /** Optional msgCode to rotate the image to be upright. Defaults to true. */
+    upright?: boolean;
+    /** Optional msgCode indicating if the photo data is raw (headerless JPEG). Defaults to false. */
+    isRaw?: boolean;
+    /** Optional JPEG quality setting. Required for raw images if header is not cached. */
+    quality?: JpegQuality | null;
+    /** Optional photo resolution (e.g., height in pixels). Must be an even number between 100 and 720. Required for raw images if header is not cached. */
+    resolution?: number | null;
+}
+/**
+ * RxPhoto class handles JPEG image data streaming and processing.
+ * It can process JPEG images with or without a header ("raw" mode), although at least one
+ * compatible JPEG header must be cached before using raw mode.
+ * It can also rotate images 90 degrees counter-clockwise to upright (default behavior).
+ * Different JPEG qualities and resolutions can be specified.
+ */
+export declare class RxPhoto {
+    private static _jpegHeaderMap;
+    private nonFinalChunkMsgCode;
+    private finalChunkMsgCode;
+    private upright;
+    private isRaw;
+    private quality;
+    private resolution;
+    /** Asynchronous queue for received photo data (Uint8Array). Null if not attached. */
+    queue: AsyncQueue<Uint8Array> | null;
+    private _imageDataChunks;
+    /**
+     * Constructs an instance of the RxPhoto class.
+     * @param options Configuration options for the photo handler.
+     */
+    constructor(options?: RxPhotoOptions);
+    /**
+     * Checks if a JPEG header is cached for the given quality and resolution.
+     * @param quality The JPEG quality.
+     * @param resolution The photo resolution.
+     * @returns True if a header is cached, false otherwise.
+     */
+    static hasJpegHeader(quality: JpegQuality, resolution: number): boolean;
+    private concatenateImageData;
+    /**
+     * Handles incoming raw photo data chunks.
+     * This method is typically called by a `BrilliantMsg` instance when new photo data is received.
+     * It accumulates chunks and, upon receiving the final chunk, processes the complete image.
+     * The processed image (as a Uint8Array) is then placed onto the `queue`.
+     * @param data A Uint8Array containing the raw photo data chunk, prefixed with a msgCode byte.
+     */
+    handleData(data: Uint8Array): void;
+    private _processCompleteImage;
+    /**
+     * Attaches this RxPhoto instance to a BrilliantMsg object to receive photo data.
+     * It initializes the photo data queue and registers a handler for incoming data chunks.
+     * @param frame The BrilliantMsg instance to attach to.
+     * @returns A Promise that resolves to the `AsyncQueue` where complete photo data (Uint8Array) will be placed.
+     */
+    attach(frame: BrilliantMsg): Promise<AsyncQueue<Uint8Array>>;
+    /**
+     * Detaches this RxPhoto instance from a BrilliantMsg object.
+     * It unregisters the data handler and clears the photo data queue and any pending chunks.
+     * @param frame The BrilliantMsg instance to detach from.
+     */
+    detach(frame: BrilliantMsg): void;
+    /**
+     * Rotates a JPEG image 90 degrees counter-clockwise using an offscreen canvas.
+     * @param inputBytes The input JPEG image as a Uint8Array.
+     * @returns the rotated JPEG image as a Uint8Array.
+     */
+    rotateJpeg90CounterClockwise(inputBytes: Uint8Array): Promise<Uint8Array>;
+}

package/dist/rx/tap.d.ts

@@ -0,0 +1,62 @@
+import { BrilliantMsg } from '../brilliant-msg';
+import { AsyncQueue } from '../async-queue';
+/**
+ * Configuration options for the RxTap class.
+ */
+export interface RxTapOptions {
+    /**
+     * Optional msgCode byte used to identify tap event packets received from the Frame device.
+     * Defaults to 0x09.
+     */
+    msgCode?: number;
+    /**
+     * Optional time window in seconds within which multiple taps are counted as a single event.
+     * Defaults to 0.3 seconds.
+     */
+    threshold?: number;
+}
+/**
+ * RxTap class handles tap events from the device.
+ * It counts the number of taps within a specified threshold time.
+ * It uses a queue to manage tap events and provides methods to attach and detach from a BrilliantMsg instance.
+ * It also debounces taps that occur too close together (40ms).
+ * The tap count is reset if no taps are detected within the threshold time.
+ */
+export declare class RxTap {
+    private msgCode;
+    private threshold;
+    /** Asynchronous queue for tap count events. Each event is a number representing the count of taps. Null if not attached. */
+    queue: AsyncQueue<number> | null;
+    private lastTapTime;
+    private tapCount;
+    private thresholdTimeoutId;
+    /**
+     * Constructs an instance of the RxTap class.
+     * @param options Configuration options for the tap handler.
+     *                Includes `msgCode` (default: 0x09) and `threshold` in seconds (default: 0.3).
+     */
+    constructor(options?: RxTapOptions);
+    private resetThresholdTimer;
+    private thresholdTimeout;
+    /**
+     * Handles incoming tap event data packets.
+     * This method is typically called by a `BrilliantMsg` instance when a tap event is received.
+     * It debounces rapid taps and counts taps within a defined threshold.
+     * The accumulated tap count is placed onto the `queue` when the threshold timer expires.
+     * @param data A Uint8Array containing the tap event data (usually just the msgCode byte).
+     */
+    handleData(data: Uint8Array): void;
+    /**
+     * Attaches this RxTap instance to a BrilliantMsg object to receive tap event data.
+     * It initializes the tap event queue and registers a handler for incoming data.
+     * @param frame The BrilliantMsg instance to attach to.
+     * @returns A Promise that resolves to the `AsyncQueue` where tap counts (number) will be placed.
+     */
+    attach(frame: BrilliantMsg): Promise<AsyncQueue<number>>;
+    /**
+     * Detaches this RxTap instance from a BrilliantMsg object.
+     * It unregisters the data handler, clears any active timers, and clears the event queue.
+     * @param frame The BrilliantMsg instance to detach from.
+     */
+    detach(frame: BrilliantMsg): void;
+}

package/dist/tx/auto-exp-settings.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Options for configuring auto exposure and gain settings.
+ */
+export interface TxAutoExpSettingsOptions {
+    /** Optional zero-based index into metering modes ['SPOT', 'CENTER_WEIGHTED', 'AVERAGE'] (0, 1, or 2). Defaults to 1 (CENTER_WEIGHTED). */
+    meteringIndex?: number;
+    /** Optional target exposure value (0.0-1.0). Defaults to 0.1. */
+    exposure?: number;
+    /** Optional speed of exposure adjustments (0.0-1.0). Defaults to 0.45. */
+    exposureSpeed?: number;
+    /** Optional maximum shutter value (4-16383). Defaults to 16383. */
+    shutterLimit?: number;
+    /** Optional maximum analog gain value (1-248). Defaults to 16. */
+    analogGainLimit?: number;
+    /** Optional speed of white balance adjustments (0.0-1.0). Defaults to 0.5. */
+    whiteBalanceSpeed?: number;
+    /** Optional maximum gain value for red, green, blue channels (0-1023). Defaults to 287. */
+    rgbGainLimit?: number;
+}
+/**
+ * Message for auto exposure and gain settings.
+ */
+export declare class TxAutoExpSettings {
+    /**
+     * Zero-based index into ['SPOT', 'CENTER_WEIGHTED', 'AVERAGE'] i.e. 0, 1 or 2.
+     */
+    meteringIndex: number;
+    /**
+     * Target exposure value (0.0-1.0)
+     */
+    exposure: number;
+    /**
+     * Speed of exposure adjustments (0.0-1.0)
+     */
+    exposureSpeed: number;
+    /**
+     * Maximum shutter value (4-16383)
+     */
+    shutterLimit: number;
+    /**
+     * Maximum analog gain value (1-248)
+     */
+    analogGainLimit: number;
+    /**
+     * Speed of white balance adjustments (0.0-1.0)
+     */
+    whiteBalanceSpeed: number;
+    /**
+     * Maximum gain value for red, green, blue channels (0-1023)
+     */
+    rgbGainLimit: number;
+    /**
+     * Constructs an instance of TxAutoExpSettings.
+     * @param options Configuration options for auto exposure and gain settings.
+     */
+    constructor(options?: TxAutoExpSettingsOptions);
+    /**
+     * Packs the settings into 9 bytes.
+     * @returns Uint8Array Binary representation of the message (9 bytes)
+     */
+    pack(): Uint8Array;
+}