nmea-web-serial 1.1.2 → 1.1.4

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

@@ -1,19 +1,12 @@
-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 { HDTPacket } from 'nmea-simple';
-import { MachineSnapshot } from 'xstate';
 import { MetaObject } from 'xstate';
 import { NonReducibleUnknown } from 'xstate';
 import { Packet } from 'nmea-simple';
@@ -21,910 +14,33 @@ 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';
 
 /**
- * Simple client for navigation NMEA data.
- * Creates a machine and manages connection state automatically.
- *
- * @param options - Configuration options.
- * @returns A client instance for managing the NMEA connection.
- *
- * @example
- * ```typescript
- * const client = createNavigationNmeaClient({
- *   enableLogging: true,
- *   onData: (navigation) => {
- *     console.log('Position:', navigation.position);
- *   },
- * });
- *
- * client.connect();
- * ```
- */
-export declare function createNavigationNmeaClient(options?: NmeaClientOptions<NavigationData>): NmeaClient<NavigationData, StoredPackets>;
-
-/**
- * Convenience function to create a navigation-focused NMEA machine.
- * This is a pre-configured machine that computes navigation data from NMEA packets.
- *
- * @returns An NMEA machine configured for navigation data computation.
- *
- * @example
- * ```typescript
- * const machine = createNavigationNmeaMachine();
- * ```
- */
-export declare function createNavigationNmeaMachine(): 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";
-};
-};
-};
-}>;
-
-/**
- * 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";
-}, {
+ * Convenience function to create a navigation-focused NMEA machine.
+ *
+ * This is a pre-configured machine that computes navigation data (position, time, speed, heading, depth)
+ * from NMEA packets. It uses the navigation adapter which automatically handles priority-based fallback
+ * between different sentence types.
+ *
+ * @example
+ * ```typescript
+ * const machine = createNavigationNmeaMachine();
+ * const actor = createActor(machine);
+ * actor.start();
+ * actor.send({ type: 'CONNECT' });
+ * ```
+ *
+ * @returns An XState state machine configured for navigation data computation.
+ *
+ * @remarks
+ * The returned machine is an XState state machine. Use it with XState's `createActor` to create
+ * an actor instance, or use the {@link NavigationNmeaClient} class for a simpler API that doesn't
+ * require direct XState knowledge.
+ */
+export declare function createNavigationNmeaMachine(): StateMachine<NmeaContext<NavigationData, StoredPackets>, {
 type: "CONNECT";
 } | {
 type: "DISCONNECT";
@@ -947,97 +63,117 @@ 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";
+}, {
+[x: string]: ActorRefFromLogic<PromiseActorLogic<SerialPort, {
 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";
+}, EventObject>> | ActorRefFromLogic<CallbackActorLogic<NmeaEvent, {
+port: SerialPort;
+}, EventObject>> | ActorRefFromLogic<PromiseActorLogic<void, {
+port: SerialPort | null;
+}, EventObject>> | undefined;
+}, {
+src: "connectToSerial";
+logic: PromiseActorLogic<SerialPort, {
+baudRate: number;
+}, EventObject>;
+id: string | undefined;
 } | {
-type: "STOP";
+src: "readNmeaStream";
+logic: CallbackActorLogic<NmeaEvent, {
+port: SerialPort;
+}, EventObject>;
+id: string | undefined;
 } | {
-type: "SET_LOGGING";
-enabled: boolean;
+src: "closePort";
+logic: PromiseActorLogic<void, {
+port: SerialPort | null;
+}, EventObject>;
+id: string | undefined;
+}, {
+type: "setPort";
+params: {
+port: SerialPort;
+};
 } | {
-type: "SET_BAUD_RATE";
-baudRate: number;
-}, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
-type: "CONNECT";
+type: "setError";
+params: {
+error: unknown;
+};
 } | {
-type: "DISCONNECT";
+type: "logParsedData";
+params: {
+packet: Packet;
+};
 } | {
-type: "SERIAL.DATA";
-data: Packet;
+type: "storePacket";
+params: {
+packet: Packet;
+};
 } | {
-type: "SERIAL.ERROR";
+type: "clearError";
+params: {
 error: string;
+};
 } | {
-type: "FATAL_ERROR";
+type: "setFatalError";
+params: {
 error: string;
+};
 } | {
-type: "SERIAL.DISCONNECTED";
-} | {
-type: "STOP";
+type: "disconnect";
+params: NonReducibleUnknown;
 } | {
-type: "SET_LOGGING";
+type: "setLogging";
+params: {
 enabled: boolean;
+};
 } | {
-type: "SET_BAUD_RATE";
+type: "setBaudRate";
+params: {
 baudRate: number;
-}, AnyEventObject>;
-}) => {
-port: SerialPort;
-};
 };
+}, never, never, "error" | "disconnected" | "connecting" | "connected" | "disconnecting", string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
+id: "nmea";
+states: {
+readonly disconnected: {};
+readonly connecting: {};
+readonly connected: {};
+readonly disconnecting: {};
+readonly error: {};
 };
-readonly disconnecting: {
-readonly invoke: {
-readonly id: "closePort";
-readonly src: "closePort";
-readonly input: ({ context }: {
-context: NmeaContext<TData, TPackets>;
-event: {
+}>;
+
+/**
+ * Factory function to create an NMEA state machine with a generic adapter pattern.
+ *
+ * Creates an XState state machine that manages serial port connections, parses NMEA sentences,
+ * and transforms them into your application's data format using the provided adapter function.
+ *
+ * @example
+ * ```typescript
+ * const machine = createNmeaMachine({
+ *   adapter: computeNavigationData,
+ *   allowedSentenceIds: ['GGA', 'RMC', 'VTG'],
+ *   initialData: { time: null, position: null },
+ *   initialPackets: {},
+ * });
+ *
+ * const actor = createActor(machine);
+ * actor.start();
+ * actor.send({ type: 'CONNECT' });
+ * ```
+ *
+ * @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 state machine that can be used with `createActor` from XState.
+ *
+ * @remarks
+ * The returned machine is an XState state machine. Use it with XState's `createActor` to create
+ * an actor instance, or use the {@link NmeaClient} class for a simpler API that doesn't require
+ * direct XState knowledge.
+ */
+export declare function createNmeaMachine<TData, TPackets extends Record<string, PacketStub | undefined>>(config: NmeaMachineConfig<TData, TPackets>): StateMachine<NmeaContext<TData, TPackets>, {
 type: "CONNECT";
 } | {
 type: "DISCONNECT";
@@ -1060,90 +196,101 @@ 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";
+}, {
+[x: string]: ActorRefFromLogic<PromiseActorLogic<SerialPort, {
+baudRate: number;
+}, EventObject>> | ActorRefFromLogic<CallbackActorLogic<NmeaEvent, {
+port: SerialPort;
+}, EventObject>> | ActorRefFromLogic<PromiseActorLogic<void, {
+port: SerialPort | null;
+}, EventObject>> | undefined;
+}, {
+src: "connectToSerial";
+logic: PromiseActorLogic<SerialPort, {
+baudRate: number;
+}, EventObject>;
+id: string | undefined;
 } | {
-type: "STOP";
+src: "readNmeaStream";
+logic: CallbackActorLogic<NmeaEvent, {
+port: SerialPort;
+}, EventObject>;
+id: string | undefined;
 } | {
-type: "SET_LOGGING";
-enabled: boolean;
+src: "closePort";
+logic: PromiseActorLogic<void, {
+port: SerialPort | null;
+}, EventObject>;
+id: string | undefined;
+}, {
+type: "setPort";
+params: {
+port: SerialPort;
+};
 } | {
-type: "SET_BAUD_RATE";
-baudRate: number;
-}, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
-type: "CONNECT";
+type: "setError";
+params: {
+error: unknown;
+};
 } | {
-type: "DISCONNECT";
+type: "logParsedData";
+params: {
+packet: Packet;
+};
 } | {
-type: "SERIAL.DATA";
-data: Packet;
+type: "storePacket";
+params: {
+packet: Packet;
+};
 } | {
-type: "SERIAL.ERROR";
+type: "clearError";
+params: {
 error: string;
+};
 } | {
-type: "FATAL_ERROR";
+type: "setFatalError";
+params: {
 error: string;
+};
 } | {
-type: "SERIAL.DISCONNECTED";
-} | {
-type: "STOP";
+type: "disconnect";
+params: NonReducibleUnknown;
 } | {
-type: "SET_LOGGING";
+type: "setLogging";
+params: {
 enabled: boolean;
+};
 } | {
-type: "SET_BAUD_RATE";
+type: "setBaudRate";
+params: {
 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";
-};
 };
+}, never, never, "error" | "disconnected" | "connecting" | "connected" | "disconnecting", string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
+id: "nmea";
+states: {
+readonly disconnected: {};
+readonly connecting: {};
+readonly connected: {};
+readonly disconnecting: {};
+readonly error: {};
 };
 }>;
 
 declare type CustomPackets = DBSPacket | DBKPacket | DPTPacket;
 
-export declare interface DBKPacket extends PacketStub<typeof sentenceId_3> {
+declare interface DBKPacket extends PacketStub<typeof sentenceId_3> {
     depthFeet: number;
     depthMeters: number;
     depthFathoms: number;
 }
 
-export declare interface DBSPacket extends PacketStub<typeof sentenceId_2> {
+declare interface DBSPacket extends PacketStub<typeof sentenceId_2> {
     depthFeet: number;
     depthMeters: number;
     depthFathoms: number;
 }
 
-export declare interface DPTPacket extends PacketStub<typeof sentenceId> {
+declare interface DPTPacket extends PacketStub<typeof sentenceId> {
     depthMeters: number;
     offsetMeters: number;
     maximumRangeScale: number;
@@ -1185,11 +332,36 @@ export declare interface NavigationData {
     } | null;
 }
 
+/**
+ * Simple client for navigation NMEA data.
+ * Creates a machine and manages connection state automatically.
+ *
+ * @example
+ * ```typescript
+ * const client = new NavigationNmeaClient({
+ *   enableLogging: true,
+ *   onData: (navigation) => {
+ *     console.log('Position:', navigation.position);
+ *   },
+ * });
+ *
+ * client.connect();
+ * ```
+ */
+export declare class NavigationNmeaClient extends NmeaClient<NavigationData, StoredPackets> {
+    /**
+     * Creates a new navigation NMEA client.
+     *
+     * @param options - Optional configuration and callbacks.
+     */
+    constructor(options?: NmeaClientOptions<NavigationData>);
+}
+
 /**
  * Simple client for managing NMEA connections.
  * Abstracts away XState details while still exposing the machine for advanced use.
  */
-export declare class NmeaClient<TData, TPackets extends Record<string, unknown>> {
+export declare class NmeaClient<TData, TPackets extends Record<string, PacketStub | undefined>> {
     private actor;
     private subscription;
     private options?;
@@ -1265,7 +437,7 @@ export declare interface NmeaClientOptions<TData = unknown> {
  * @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>> {
+declare interface NmeaContext<TData, TPackets extends Record<string, PacketStub | undefined>> {
     /** The active Web Serial port connection, or null if disconnected. */
     port: SerialPort | null;
     /** Current error message, or null if no error. */
@@ -1283,7 +455,7 @@ export declare interface NmeaContext<TData, TPackets extends Record<string, unkn
 /**
  * Events that the NMEA state machine can handle.
  */
-export declare type NmeaEvent = {
+declare type NmeaEvent = {
     type: 'CONNECT';
 } | {
     type: 'DISCONNECT';
@@ -1313,14 +485,14 @@ export declare type NmeaEvent = {
  * @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>>>;
+export declare type NmeaMachineActor<TData, TPackets extends Record<string, PacketStub | undefined>> = 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>> {
+export declare interface NmeaMachineConfig<TData, TPackets extends Record<string, PacketStub | undefined>> {
     /** 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. */
@@ -1331,8 +503,6 @@ export declare interface NmeaMachineConfig<TData, TPackets extends Record<string
     initialPackets: TPackets;
 }
 
-export { Packet }
-
 export declare function parseNmeaSentence(sentence: string): ExtendedNmeaPacket;
 
 export declare function parseUnsafeNmeaSentence(sentence: string): ExtendedNmeaPacket | UnknownPacket;
@@ -1346,7 +516,7 @@ declare const sentenceId_3: "DBK";
 /**
  * Types for stored packets by sentence type.
  */
-export declare interface StoredPackets extends Record<string, unknown> {
+export declare interface StoredPackets extends Record<string, PacketStub | undefined> {
     GGA?: GGAPacket;
     RMC?: RMCPacket;
     GLL?: GLLPacket;