nmea-web-serial 1.0.0

package/dist/nmea-web-serial.d.ts

@@ -0,0 +1,1421 @@
+import { ActionFunction } from 'xstate';
+import { ActorRef } from 'xstate';
+import { ActorRefFrom } from 'xstate';
+import { ActorRefFromLogic } from 'xstate';
+import { AnyActorRef } from 'xstate';
+import { AnyEventObject } from 'xstate';
+import { CallbackActorLogic } from 'xstate';
+import { DBTPacket } from 'nmea-simple';
+import { DoneActorEvent } from 'xstate';
+import { ErrorActorEvent } from 'xstate';
+import { EventObject } from 'xstate';
+import { GGAPacket } from 'nmea-simple';
+import { GLLPacket } from 'nmea-simple';
+import { HDGPacket } from 'nmea-simple';
+import { HDMPacket } from 'nmea-simple';
+import { HDTPacket } from 'nmea-simple';
+import { MachineSnapshot } from 'xstate';
+import { MetaObject } from 'xstate';
+import { NonReducibleUnknown } from 'xstate';
+import { Packet } from 'nmea-simple';
+import { PacketStub } from 'nmea-simple/dist/codecs/PacketStub';
+import { PromiseActorLogic } from 'xstate';
+import { RMCPacket } from 'nmea-simple';
+import { StateMachine } from 'xstate';
+import { StateValue } from 'xstate';
+import { UnknownPacket } from 'nmea-simple/dist/codecs/UnknownPacket';
+import { Values } from 'xstate';
+import { VTGPacket } from 'nmea-simple';
+import { ZDAPacket } from 'nmea-simple';
+
+/**
+ * Append the correct trailing "*xx" footer for an NMEA string and return the result.
+ */
+export declare function appendChecksumFooter(sentenceWithoutChecksum: string): string;
+
+/**
+ * Computes navigation data from stored packets using a fallback strategy.
+ * Each navigation property (time, position, speed, heading, depth) is computed
+ * with priority-based fallback to the best available data source.
+ */
+export declare function computeNavigationData(packets: StoredPackets, externalVariation?: number): NavigationData;
+
+/**
+ * Generate a checksum for an NMEA sentence without the trailing "*xx".
+ */
+export declare function computeNmeaChecksum(sentenceWithoutChecksum: string): number;
+
+/**
+ * Creates a navigation adapter function with the specified magnetic variation.
+ * The adapter is a closure that captures the variation value.
+ *
+ * @param externalVariation - Optional magnetic variation for heading calculations.
+ * @returns An adapter function that transforms packets into navigation data.
+ */
+export declare function createNavigationAdapter(externalVariation?: number): (packets: StoredPackets) => NavigationData;
+
+/**
+ * Configuration for creating a navigation-focused NMEA machine.
+ * This is a convenience configuration that uses the navigation adapter.
+ */
+export declare function createNavigationNmeaConfig(options?: {
+    allowedSentenceIds?: readonly string[];
+    externalVariation?: number;
+}): NmeaMachineConfig<NavigationData, StoredPackets>;
+
+/**
+ * Convenience function to create a navigation-focused NMEA machine.
+ * This is a pre-configured machine that computes navigation data from NMEA packets.
+ *
+ * @param options - Optional configuration for the navigation machine.
+ * @param options.allowedSentenceIds - Optional array of allowed sentence IDs.
+ * @param options.externalVariation - Optional magnetic variation for heading calculations.
+ * @returns An NMEA machine configured for navigation data computation.
+ *
+ * @example
+ * ```typescript
+ * const machine = createNavigationNmeaMachine({
+ *   externalVariation: 5.5,
+ * });
+ * ```
+ */
+export declare function createNavigationNmeaMachine(options?: {
+    allowedSentenceIds?: readonly string[];
+    externalVariation?: number;
+}): StateMachine<NmeaContext<NavigationData, StoredPackets>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, {
+[x: string]: ActorRefFromLogic<PromiseActorLogic<SerialPort, {
+baudRate: number;
+}, EventObject>> | ActorRefFromLogic<CallbackActorLogic<NmeaEvent, {
+port: SerialPort;
+}, EventObject>> | ActorRefFromLogic<PromiseActorLogic<void, {
+port: SerialPort | null;
+}, EventObject>> | undefined;
+}, Values<    {
+connectToSerial: {
+src: "connectToSerial";
+logic: PromiseActorLogic<SerialPort, {
+baudRate: number;
+}, EventObject>;
+id: string | undefined;
+};
+readNmeaStream: {
+src: "readNmeaStream";
+logic: CallbackActorLogic<NmeaEvent, {
+port: SerialPort;
+}, EventObject>;
+id: string | undefined;
+};
+closePort: {
+src: "closePort";
+logic: PromiseActorLogic<void, {
+port: SerialPort | null;
+}, EventObject>;
+id: string | undefined;
+};
+}>, Values<    {
+setPort: {
+type: "setPort";
+params: {
+port: SerialPort;
+};
+};
+setError: {
+type: "setError";
+params: {
+error: unknown;
+};
+};
+logParsedData: {
+type: "logParsedData";
+params: {
+packet: Packet;
+};
+};
+storePacket: {
+type: "storePacket";
+params: {
+packet: Packet;
+};
+};
+clearError: {
+type: "clearError";
+params: {
+error: string;
+};
+};
+setFatalError: {
+type: "setFatalError";
+params: {
+error: string;
+};
+};
+disconnect: {
+type: "disconnect";
+params: NonReducibleUnknown;
+};
+setLogging: {
+type: "setLogging";
+params: {
+enabled: boolean;
+};
+};
+setBaudRate: {
+type: "setBaudRate";
+params: {
+baudRate: number;
+};
+};
+}>, never, never, "error" | "disconnected" | "connecting" | "connected" | "disconnecting", string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
+readonly id: "nmea";
+readonly initial: "disconnected";
+readonly context: {
+readonly port: null;
+readonly error: null;
+readonly packets: StoredPackets;
+readonly data: NavigationData;
+readonly enableLogging: false;
+readonly baudRate: 4800;
+};
+readonly on: {
+readonly SET_LOGGING: {
+readonly actions: {
+readonly type: "setLogging";
+readonly params: ({ event }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "SET_LOGGING";
+enabled: boolean;
+};
+}) => {
+enabled: boolean;
+};
+};
+};
+};
+readonly states: {
+readonly disconnected: {
+readonly on: {
+readonly CONNECT: "connecting";
+readonly SET_BAUD_RATE: {
+readonly actions: {
+readonly type: "setBaudRate";
+readonly params: ({ event }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "SET_BAUD_RATE";
+baudRate: number;
+};
+}) => {
+baudRate: number;
+};
+};
+};
+};
+};
+readonly connecting: {
+readonly invoke: {
+readonly id: "connectToSerial";
+readonly src: "connectToSerial";
+readonly input: ({ context }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+};
+self: ActorRef<MachineSnapshot<NmeaContext<NavigationData, StoredPackets>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, AnyEventObject>;
+}) => {
+baudRate: number;
+};
+readonly onDone: {
+readonly target: "connected";
+readonly actions: {
+readonly type: "setPort";
+readonly params: ({ event }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: DoneActorEvent<SerialPort, string>;
+}) => {
+port: SerialPort;
+};
+};
+};
+readonly onError: {
+readonly target: "error";
+readonly actions: {
+readonly type: "setError";
+readonly params: ({ event }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: ErrorActorEvent<unknown, string>;
+}) => {
+error: unknown;
+};
+};
+};
+};
+};
+readonly connected: {
+readonly on: {
+readonly 'SERIAL.DATA': {
+readonly actions: readonly [{
+readonly type: "logParsedData";
+readonly params: ({ event }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "SERIAL.DATA";
+data: Packet;
+};
+}) => {
+packet: Packet;
+};
+}, {
+readonly type: "storePacket";
+readonly params: ({ event }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "SERIAL.DATA";
+data: Packet;
+};
+}) => {
+packet: Packet;
+};
+}];
+};
+readonly 'SERIAL.ERROR': {
+readonly actions: {
+readonly type: "clearError";
+readonly params: ({ event }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "SERIAL.ERROR";
+error: string;
+};
+}) => {
+error: string;
+};
+};
+};
+readonly FATAL_ERROR: {
+readonly target: "error";
+readonly actions: {
+readonly type: "setFatalError";
+readonly params: ({ event }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "FATAL_ERROR";
+error: string;
+};
+}) => {
+error: string;
+};
+};
+};
+readonly 'SERIAL.DISCONNECTED': {
+readonly target: "disconnecting";
+};
+readonly DISCONNECT: {
+readonly actions: ActionFunction<NmeaContext<NavigationData, StoredPackets>, {
+type: "DISCONNECT";
+}, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, undefined, never, never, never, never, never>;
+};
+};
+readonly invoke: {
+readonly id: "streamReader";
+readonly src: "readNmeaStream";
+readonly input: ({ context }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+};
+self: ActorRef<MachineSnapshot<NmeaContext<NavigationData, StoredPackets>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, AnyEventObject>;
+}) => {
+port: SerialPort;
+};
+};
+};
+readonly disconnecting: {
+readonly invoke: {
+readonly id: "closePort";
+readonly src: "closePort";
+readonly input: ({ context }: {
+context: NmeaContext<NavigationData, StoredPackets>;
+event: {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+};
+self: ActorRef<MachineSnapshot<NmeaContext<NavigationData, StoredPackets>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, AnyEventObject>;
+}) => {
+port: SerialPort | null;
+};
+readonly onDone: {
+readonly target: "disconnected";
+readonly actions: "disconnect";
+};
+readonly onError: {
+readonly target: "disconnected";
+readonly actions: "disconnect";
+};
+};
+};
+readonly error: {
+readonly on: {
+readonly CONNECT: "connecting";
+};
+};
+};
+}>;
+
+/**
+ * Generate the correct trailing "*xx" footer for an NMEA sentence.
+ */
+export declare function createNmeaChecksumFooter(sentenceWithoutChecksum: string): string;
+
+/**
+ * Factory function to create an NMEA state machine with a generic adapter pattern.
+ *
+ * @template TData - The type of computed/translated data stored in context.
+ * @template TPackets - The type of stored packets (typically a record of sentence ID to packet).
+ * @param config - Configuration for the machine including adapter function and initial values.
+ * @returns An XState machine configured with the provided adapter and types.
+ *
+ * @example
+ * ```typescript
+ * const machine = createNmeaMachine({
+ *   adapter: computeNavigationData,
+ *   allowedSentenceIds: ['GGA', 'RMC', 'VTG'],
+ *   initialData: { time: null, position: null },
+ *   initialPackets: {},
+ * });
+ * ```
+ */
+export declare function createNmeaMachine<TData, TPackets extends Record<string, unknown>>(config: NmeaMachineConfig<TData, TPackets>): StateMachine<NmeaContext<TData, TPackets>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, {
+[x: string]: ActorRefFromLogic<PromiseActorLogic<SerialPort, {
+baudRate: number;
+}, EventObject>> | ActorRefFromLogic<CallbackActorLogic<NmeaEvent, {
+port: SerialPort;
+}, EventObject>> | ActorRefFromLogic<PromiseActorLogic<void, {
+port: SerialPort | null;
+}, EventObject>> | undefined;
+}, Values<    {
+connectToSerial: {
+src: "connectToSerial";
+logic: PromiseActorLogic<SerialPort, {
+baudRate: number;
+}, EventObject>;
+id: string | undefined;
+};
+readNmeaStream: {
+src: "readNmeaStream";
+logic: CallbackActorLogic<NmeaEvent, {
+port: SerialPort;
+}, EventObject>;
+id: string | undefined;
+};
+closePort: {
+src: "closePort";
+logic: PromiseActorLogic<void, {
+port: SerialPort | null;
+}, EventObject>;
+id: string | undefined;
+};
+}>, Values<    {
+setPort: {
+type: "setPort";
+params: {
+port: SerialPort;
+};
+};
+setError: {
+type: "setError";
+params: {
+error: unknown;
+};
+};
+logParsedData: {
+type: "logParsedData";
+params: {
+packet: Packet;
+};
+};
+storePacket: {
+type: "storePacket";
+params: {
+packet: Packet;
+};
+};
+clearError: {
+type: "clearError";
+params: {
+error: string;
+};
+};
+setFatalError: {
+type: "setFatalError";
+params: {
+error: string;
+};
+};
+disconnect: {
+type: "disconnect";
+params: NonReducibleUnknown;
+};
+setLogging: {
+type: "setLogging";
+params: {
+enabled: boolean;
+};
+};
+setBaudRate: {
+type: "setBaudRate";
+params: {
+baudRate: number;
+};
+};
+}>, never, never, "error" | "disconnected" | "connecting" | "connected" | "disconnecting", string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
+readonly id: "nmea";
+readonly initial: "disconnected";
+readonly context: {
+readonly port: null;
+readonly error: null;
+readonly packets: TPackets;
+readonly data: TData;
+readonly enableLogging: false;
+readonly baudRate: 4800;
+};
+readonly on: {
+readonly SET_LOGGING: {
+readonly actions: {
+readonly type: "setLogging";
+readonly params: ({ event }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "SET_LOGGING";
+enabled: boolean;
+};
+}) => {
+enabled: boolean;
+};
+};
+};
+};
+readonly states: {
+readonly disconnected: {
+readonly on: {
+readonly CONNECT: "connecting";
+readonly SET_BAUD_RATE: {
+readonly actions: {
+readonly type: "setBaudRate";
+readonly params: ({ event }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "SET_BAUD_RATE";
+baudRate: number;
+};
+}) => {
+baudRate: number;
+};
+};
+};
+};
+};
+readonly connecting: {
+readonly invoke: {
+readonly id: "connectToSerial";
+readonly src: "connectToSerial";
+readonly input: ({ context }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+};
+self: ActorRef<MachineSnapshot<NmeaContext<TData, TPackets>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, AnyEventObject>;
+}) => {
+baudRate: number;
+};
+readonly onDone: {
+readonly target: "connected";
+readonly actions: {
+readonly type: "setPort";
+readonly params: ({ event }: {
+context: NmeaContext<TData, TPackets>;
+event: DoneActorEvent<SerialPort, string>;
+}) => {
+port: SerialPort;
+};
+};
+};
+readonly onError: {
+readonly target: "error";
+readonly actions: {
+readonly type: "setError";
+readonly params: ({ event }: {
+context: NmeaContext<TData, TPackets>;
+event: ErrorActorEvent<unknown, string>;
+}) => {
+error: unknown;
+};
+};
+};
+};
+};
+readonly connected: {
+readonly on: {
+readonly 'SERIAL.DATA': {
+readonly actions: readonly [{
+readonly type: "logParsedData";
+readonly params: ({ event }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "SERIAL.DATA";
+data: Packet;
+};
+}) => {
+packet: Packet;
+};
+}, {
+readonly type: "storePacket";
+readonly params: ({ event }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "SERIAL.DATA";
+data: Packet;
+};
+}) => {
+packet: Packet;
+};
+}];
+};
+readonly 'SERIAL.ERROR': {
+readonly actions: {
+readonly type: "clearError";
+readonly params: ({ event }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "SERIAL.ERROR";
+error: string;
+};
+}) => {
+error: string;
+};
+};
+};
+readonly FATAL_ERROR: {
+readonly target: "error";
+readonly actions: {
+readonly type: "setFatalError";
+readonly params: ({ event }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "FATAL_ERROR";
+error: string;
+};
+}) => {
+error: string;
+};
+};
+};
+readonly 'SERIAL.DISCONNECTED': {
+readonly target: "disconnecting";
+};
+readonly DISCONNECT: {
+readonly actions: ActionFunction<NmeaContext<TData, TPackets>, {
+type: "DISCONNECT";
+}, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, undefined, never, never, never, never, never>;
+};
+};
+readonly invoke: {
+readonly id: "streamReader";
+readonly src: "readNmeaStream";
+readonly input: ({ context }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+};
+self: ActorRef<MachineSnapshot<NmeaContext<TData, TPackets>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, AnyEventObject>;
+}) => {
+port: SerialPort;
+};
+};
+};
+readonly disconnecting: {
+readonly invoke: {
+readonly id: "closePort";
+readonly src: "closePort";
+readonly input: ({ context }: {
+context: NmeaContext<TData, TPackets>;
+event: {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+};
+self: ActorRef<MachineSnapshot<NmeaContext<TData, TPackets>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+type: "CONNECT";
+} | {
+type: "DISCONNECT";
+} | {
+type: "SERIAL.DATA";
+data: Packet;
+} | {
+type: "SERIAL.ERROR";
+error: string;
+} | {
+type: "FATAL_ERROR";
+error: string;
+} | {
+type: "SERIAL.DISCONNECTED";
+} | {
+type: "STOP";
+} | {
+type: "SET_LOGGING";
+enabled: boolean;
+} | {
+type: "SET_BAUD_RATE";
+baudRate: number;
+}, AnyEventObject>;
+}) => {
+port: SerialPort | null;
+};
+readonly onDone: {
+readonly target: "disconnected";
+readonly actions: "disconnect";
+};
+readonly onError: {
+readonly target: "disconnected";
+readonly actions: "disconnect";
+};
+};
+};
+readonly error: {
+readonly on: {
+readonly CONNECT: "connecting";
+};
+};
+};
+}>;
+
+declare type CustomPackets = DBSPacket | DBKPacket | DPTPacket;
+
+export declare interface DBKPacket extends PacketStub<typeof sentenceId_3> {
+    depthFeet: number;
+    depthMeters: number;
+    depthFathoms: number;
+}
+
+export declare interface DBSPacket extends PacketStub<typeof sentenceId_2> {
+    depthFeet: number;
+    depthMeters: number;
+    depthFathoms: number;
+}
+
+export declare interface DPTPacket extends PacketStub<typeof sentenceId> {
+    depthMeters: number;
+    offsetMeters: number;
+    maximumRangeScale: number;
+}
+
+export declare function encodeAltitude(alt: number): string;
+
+export declare function encodeAltitudeNoUnits(alt: number): string;
+
+export declare function encodeDate(date?: Date): string;
+
+export declare function encodeDegrees(degrees?: number): string;
+
+export declare function encodeFixed(value: number | undefined, decimalPlaces: number): string;
+
+export declare function encodeGeoidalSeperation(geoidalSep: number): string;
+
+export declare function encodeGeoidalSeperationNoUnits(geoidalSep: number): string;
+
+/**
+ * Encodes the latitude in the standard NMEA format "ddmm.mmmmmm".
+ *
+ * @param latitude Latitude in decimal degrees.
+ */
+export declare function encodeLatitude(latitude?: number): string;
+
+/**
+ * Encodes the longitude in the standard NMEA format "dddmm.mmmmmm".
+ *
+ * @param longitude Longitude in decimal degrees.
+ */
+export declare function encodeLongitude(longitude?: number): string;
+
+export declare function encodeTime(date?: Date): string;
+
+export declare function encodeValue(value?: unknown): string;
+
+declare type ExtendedNmeaPacket = Packet | CustomPackets;
+
+/**
+ * Initial navigation data state.
+ */
+export declare const initialNavigationData: NavigationData;
+
+/**
+ * Initial stored packets state.
+ */
+export declare const initialNavigationPackets: StoredPackets;
+
+/**
+ * Default sentence IDs used for navigation data computation.
+ * Includes standard NMEA sentences and custom depth sentences.
+ */
+export declare const NAVIGATION_SENTENCE_IDS: readonly ["GGA", "RMC", "GLL", "VTG", "HDT", "HDG", "HDM", "DPT", "DBT", "DBS", "DBK", "ZDA"];
+
+/**
+ * Types for navigation data.
+ */
+export declare interface NavigationData {
+    time: {
+        utc: Date;
+        local: Date | null;
+        source: 'ZDA' | 'GGA' | 'RMC' | 'GLL' | null;
+    } | null;
+    position: {
+        latitude: number;
+        longitude: number;
+        source: 'GGA' | 'RMC' | 'GLL' | null;
+        fixType?: 'none' | 'fix' | 'delta' | 'pps' | 'rtk' | 'frtk' | 'estimated' | 'manual' | 'simulation';
+        status?: 'valid' | 'warning' | 'invalid';
+        altitudeMeters?: number;
+        satellitesInView?: number;
+        horizontalDilution?: number;
+    } | null;
+    speed: {
+        knots: number;
+        source: 'VTG' | 'RMC' | null;
+    } | null;
+    heading: {
+        degreesTrue: number;
+        source: 'HDT' | 'HDG' | 'HDM' | 'COG' | null;
+        isDerived: boolean;
+    } | null;
+    depth: {
+        meters: number;
+        source: 'DPT' | 'DBT' | 'DBS' | 'DBK' | null;
+    } | null;
+}
+
+/**
+ * Generic context for the NMEA state machine.
+ * @template TData - The type of computed/translated data.
+ * @template TPackets - The type of stored packets.
+ */
+export declare interface NmeaContext<TData, TPackets extends Record<string, unknown>> {
+    /** The active Web Serial port connection, or null if disconnected. */
+    port: SerialPort | null;
+    /** Current error message, or null if no error. */
+    error: string | null;
+    /** Map of stored NMEA packets by sentence ID. */
+    packets: TPackets;
+    /** Computed/translated data derived from stored packets via the adapter. */
+    data: TData;
+    /** Whether to log parsed NMEA packets to the console. */
+    enableLogging: boolean;
+    /** Baud rate for serial port communication. Default is 4800 (standard NMEA rate). */
+    baudRate: number;
+}
+
+/**
+ * Events that the NMEA state machine can handle.
+ */
+export declare type NmeaEvent = {
+    type: 'CONNECT';
+} | {
+    type: 'DISCONNECT';
+} | {
+    type: 'SERIAL.DATA';
+    data: Packet;
+} | {
+    type: 'SERIAL.ERROR';
+    error: string;
+} | {
+    type: 'FATAL_ERROR';
+    error: string;
+} | {
+    type: 'SERIAL.DISCONNECTED';
+} | {
+    type: 'STOP';
+} | {
+    type: 'SET_LOGGING';
+    enabled: boolean;
+} | {
+    type: 'SET_BAUD_RATE';
+    baudRate: number;
+};
+
+/**
+ * Type helper to extract the machine type from the factory function.
+ * @template TData - The type of computed/translated data.
+ * @template TPackets - The type of stored packets.
+ */
+export declare type NmeaMachineActor<TData, TPackets extends Record<string, unknown>> = ActorRefFrom<ReturnType<typeof createNmeaMachine<TData, TPackets>>>;
+
+/**
+ * Configuration for creating an NMEA machine.
+ * @template TData - The type of computed/translated data stored in context.
+ * @template TPackets - The type of stored packets (typically a record of sentence ID to packet).
+ */
+export declare interface NmeaMachineConfig<TData, TPackets extends Record<string, unknown>> {
+    /** Function that transforms stored packets into the computed data type. */
+    adapter: (packets: TPackets) => TData;
+    /** Optional list of sentence IDs to filter and store. If not provided, all parsed sentences are stored. */
+    allowedSentenceIds?: readonly string[];
+    /** Initial computed data value. */
+    initialData: TData;
+    /** Initial stored packets value. */
+    initialPackets: TPackets;
+}
+
+export declare function padLeft(value: string | number, length: number, paddingCharacter: string): string;
+
+/**
+ * Parses coordinate given as "dddmm.mm", "ddmm.mm", "dmm.mm" or "mm.mm"
+ */
+export declare function parseDmCoordinate(coordinate: string): number;
+
+/**
+ * Parse the given string to a float, returning 0 for an empty string.
+ */
+export declare function parseFloatSafe(str: string): number;
+
+/**
+ * Parse the given string to a integer, returning 0 for an empty string.
+ */
+export declare function parseIntSafe(i: string): number;
+
+/**
+ * Parses latitude given as "ddmm.mm", "dmm.mm" or "mm.mm" (assuming zero
+ * degrees) along with a given hemisphere of "N" or "S" into decimal degrees,
+ * where north is positive and south is negative.
+ */
+export declare function parseLatitude(lat: string, hemi: string): number;
+
+/**
+ * Parses latitude given as "dddmm.mm", "ddmm.mm", "dmm.mm" or "mm.mm" (assuming
+ * zero degrees) along with a given hemisphere of "E" or "W" into decimal
+ * degrees, where east is positive and west is negative.
+ */
+export declare function parseLongitude(lon: string, hemi: string): number;
+
+export declare function parseNmeaSentence(sentence: string): ExtendedNmeaPacket;
+
+/**
+ * Parse the given string to a float if possible, returning 0 for an undefined
+ * value and a string the the given string cannot be parsed.
+ */
+export declare function parseNumberOrString(str?: string): number | string;
+
+/**
+ * Parses a UTC time and optionally a date and returns a Date
+ * object.
+ * @param {string} time Time the format "hhmmss" or "hhmmss.ss"
+ * @param {string=} date Optional date in format the ddmmyyyy or ddmmyy
+ * @returns {Date}
+ */
+export declare function parseTime(time: string, date?: string, rmcCompatible?: boolean): Date;
+
+export declare function parseUnsafeNmeaSentence(sentence: string): ExtendedNmeaPacket | UnknownPacket;
+
+declare const sentenceId: "DPT";
+
+declare const sentenceId_2: "DBS";
+
+declare const sentenceId_3: "DBK";
+
+/**
+ * Types for stored packets by sentence type.
+ */
+export declare interface StoredPackets extends Record<string, unknown> {
+    GGA?: GGAPacket;
+    RMC?: RMCPacket;
+    GLL?: GLLPacket;
+    VTG?: VTGPacket;
+    HDT?: HDTPacket;
+    HDG?: HDGPacket;
+    HDM?: HDMPacket;
+    DPT?: DPTPacket;
+    DBT?: DBTPacket;
+    DBS?: DBSPacket;
+    DBK?: DBKPacket;
+    ZDA?: ZDAPacket;
+}
+
+/**
+ * Utility functions for NMEA encoding, decoding, and validation.
+ */
+export declare function toHexString(v: number): string;
+
+export declare type UnsafeAndCustomPackets = CustomPackets | UnknownPacket;
+
+/**
+ * Checks that the given NMEA sentence has a valid checksum.
+ */
+export declare function validNmeaChecksum(nmeaSentence: string): boolean;
+
+export { }