@ceralive/modem-control 0.2.0 → 1.1.0

package/dist/transport/signals.d.ts

@@ -0,0 +1,15 @@
+import { type RawBus, type RawMessage } from './dbus-native.js';
+import type { SignalListener, SignalSpec, Subscription } from './types.js';
+export interface SignalHost {
+    currentBus(): RawBus | null;
+    isConnected(): boolean;
+    emitError(error: unknown): void;
+}
+export declare class SignalRegistry {
+    #private;
+    constructor(host: SignalHost);
+    subscribe(spec: SignalSpec, listener: SignalListener): Promise<Subscription>;
+    count(): number;
+    reissueRules(bus: RawBus): Promise<void>;
+    dispatch(message: RawMessage): void;
+}

package/dist/transport/signals.js

@@ -0,0 +1,123 @@
+// Signal subscription and match-rule tracking for the D-Bus transport seam.
+//
+// The transport's single persistent `message` listener fans out here: `dispatch` walks the
+// live subscription registry and delivers each decoded signal to every matching listener.
+// Match rules are refcounted so N subscriptions sharing a rule add/remove it on the bus
+// exactly once, and `reissueRules` re-adds every live rule after a reconnect — so
+// subscribing/unsubscribing never grows the connection's listener count (the 100-cycle
+// leak check depends on this).
+import { decodeBody } from './codec.js';
+import { messageType } from './dbus-native.js';
+function buildMatchRule(spec) {
+    const parts = [`type='signal'`, `interface='${spec.interface}'`, `member='${spec.member}'`];
+    if (spec.path !== undefined) {
+        parts.push(`path='${spec.path}'`);
+    }
+    if (spec.sender !== undefined) {
+        parts.push(`sender='${spec.sender}'`);
+    }
+    return parts.join(',');
+}
+function signalMatches(spec, message) {
+    if (message.interface !== spec.interface || message.member !== spec.member) {
+        return false;
+    }
+    if (spec.path !== undefined && message.path !== spec.path) {
+        return false;
+    }
+    if (spec.sender !== undefined && message.sender !== spec.sender) {
+        return false;
+    }
+    return true;
+}
+export class SignalRegistry {
+    #host;
+    #subscriptions = new Map();
+    #matchRuleRefcount = new Map();
+    #nextSubId = 1;
+    constructor(host) {
+        this.#host = host;
+    }
+    async subscribe(spec, listener) {
+        const rule = buildMatchRule(spec);
+        const id = this.#nextSubId++;
+        this.#subscriptions.set(id, { id, spec, listener, rule });
+        await this.#addMatchRule(rule);
+        let removed = false;
+        return {
+            unsubscribe: async () => {
+                if (removed) {
+                    return;
+                }
+                removed = true;
+                this.#subscriptions.delete(id);
+                await this.#removeMatchRule(rule);
+            },
+        };
+    }
+    count() {
+        return this.#subscriptions.size;
+    }
+    // Re-issue every live match rule against a freshly established bus so a reconnect
+    // resubscribes transparently. Called by `#establish` before it swaps in the new bus, so
+    // the fresh bus is passed in explicitly rather than read from the host.
+    async reissueRules(bus) {
+        for (const rule of this.#matchRuleRefcount.keys()) {
+            await bus.addMatch(rule);
+        }
+    }
+    dispatch(message) {
+        if (message.type !== messageType.signal) {
+            return;
+        }
+        for (const record of this.#subscriptions.values()) {
+            if (!signalMatches(record.spec, message)) {
+                continue;
+            }
+            let body;
+            try {
+                const signature = message.signature ?? '';
+                body = signature.length > 0 ? decodeBody(signature, message.body ?? []) : [];
+            }
+            catch (error) {
+                this.#host.emitError(error);
+                continue;
+            }
+            const event = {
+                path: message.path ?? '',
+                interface: message.interface ?? '',
+                member: message.member ?? '',
+                sender: message.sender,
+                signature: message.signature ?? '',
+                body,
+            };
+            try {
+                record.listener(event);
+            }
+            catch (error) {
+                this.#host.emitError(error);
+            }
+        }
+    }
+    async #addMatchRule(rule) {
+        const current = this.#matchRuleRefcount.get(rule) ?? 0;
+        this.#matchRuleRefcount.set(rule, current + 1);
+        const bus = this.#host.currentBus();
+        if (current === 0 && this.#host.isConnected() && bus) {
+            await bus.addMatch(rule);
+        }
+    }
+    async #removeMatchRule(rule) {
+        const current = this.#matchRuleRefcount.get(rule) ?? 0;
+        if (current <= 1) {
+            this.#matchRuleRefcount.delete(rule);
+            const bus = this.#host.currentBus();
+            if (current === 1 && this.#host.isConnected() && bus) {
+                await bus.removeMatch(rule).catch(() => undefined);
+            }
+        }
+        else {
+            this.#matchRuleRefcount.set(rule, current - 1);
+        }
+    }
+}

package/dist/transport/signature.d.ts

@@ -0,0 +1,7 @@
+export interface SignatureNode {
+    readonly type: string;
+    readonly child: readonly SignatureNode[];
+}
+export declare function assertSupportedSignature(signature: string): void;
+export declare function parseSignature(signature: string): SignatureNode[];
+export declare function signatureFromNode(node: SignatureNode): string;

package/dist/transport/signature.js

@@ -0,0 +1,94 @@
+// D-Bus signature parsing and support checks.
+//
+// We keep our own tiny recursive-descent parser rather than reaching into the
+// underlying library's internal `lib/signature.js`: the parsed tree drives our
+// signature-aware encode/decode (below) and the tree shape is part of this seam's
+// contract, not the library's. The node shape intentionally mirrors the library's
+// (`{ type, child }`) so a tree the library hands us inside a decoded variant can be
+// re-serialised with `signatureFromNode` without a translation step.
+import { UnsupportedSignatureError } from './errors.js';
+const CONTAINER_CLOSE = {
+    '{': '}',
+    '(': ')',
+};
+// Every basic and container type char D-Bus defines. `h` (UNIX_FD) is deliberately
+// listed as *known* so the parser accepts it structurally — we reject it explicitly in
+// `assertSupportedSignature` with a typed error rather than as a vague parse failure.
+const KNOWN_TYPES = new Set('ybnqiuxtdsogarvhe{}()'.split(''));
+// UNIX_FD: file-descriptor passing. Unsupported everywhere in this transport.
+const UNSUPPORTED_TYPE = 'h';
+// Throws UnsupportedSignatureError if the signature contains `h` anywhere (including
+// nested inside arrays, structs, dict entries, or variants). Signatures are pure type
+// strings, so a plain character scan is exact.
+export function assertSupportedSignature(signature) {
+    const index = signature.indexOf(UNSUPPORTED_TYPE);
+    if (index !== -1) {
+        throw new UnsupportedSignatureError(signature, UNSUPPORTED_TYPE);
+    }
+}
+// Parse a full signature (which may contain several top-level complete types) into a
+// flat list of nodes.
+export function parseSignature(signature) {
+    let index = 0;
+    function next() {
+        if (index < signature.length) {
+            const char = signature[index];
+            index += 1;
+            return char;
+        }
+        return null;
+    }
+    function parseOne(char) {
+        if (!KNOWN_TYPES.has(char)) {
+            throw new Error(`Unknown D-Bus type "${char}" in signature "${signature}"`);
+        }
+        const children = [];
+        switch (char) {
+            case 'a': {
+                const element = next();
+                if (element === null) {
+                    throw new Error(`Bad signature "${signature}": array with no element type`);
+                }
+                children.push(parseOne(element));
+                return { type: 'a', child: children };
+            }
+            case '{':
+            case '(': {
+                const close = CONTAINER_CLOSE[char];
+                let element = next();
+                while (element !== null && element !== close) {
+                    children.push(parseOne(element));
+                    element = next();
+                }
+                if (element === null) {
+                    throw new Error(`Bad signature "${signature}": unterminated "${char}"`);
+                }
+                return { type: char, child: children };
+            }
+            default:
+                return { type: char, child: children };
+        }
+    }
+    const nodes = [];
+    let char = next();
+    while (char !== null) {
+        nodes.push(parseOne(char));
+        char = next();
+    }
+    return nodes;
+}
+// Re-serialise a single parsed node back to its signature string. Used to recover the
+// inner signature of a decoded variant, whose contained type the library hands us as a
+// parse tree rather than a string.
+export function signatureFromNode(node) {
+    switch (node.type) {
+        case 'a':
+            return `a${signatureFromNode(node.child[0])}`;
+        case '(':
+            return `(${node.child.map(signatureFromNode).join('')})`;
+        case '{':
+            return `{${node.child.map(signatureFromNode).join('')}}`;
+        default:
+            return node.type;
+    }
+}

package/dist/transport/transport.d.ts

@@ -0,0 +1,2 @@
+import type { DbusTransport, DbusTransportOptions } from './types.js';
+export declare function createDbusTransport(options?: DbusTransportOptions): DbusTransport;

package/dist/transport/transport.js

@@ -0,0 +1,202 @@
+// The D-Bus transport seam implementation.
+//
+// Wraps `@httptoolkit/dbus-native` behind the `DbusTransport` interface. This module owns the
+// connection lifecycle — handshake, a reconnect loop that re-issues every match rule after a
+// bus restart, and teardown — and delegates method-call dispatch to `./calls` and signal
+// subscription/match-rule tracking to `./signals`. Its single `message` listener fans out to
+// the signal registry, so subscribing never grows the listener count (the 100-cycle leak check).
+import { EventEmitter } from 'node:events';
+import { CallDispatcher, DEFAULT_CALL_TIMEOUT_MS } from './calls.js';
+import { createClient, } from './dbus-native.js';
+import { DisconnectedError, TransportError } from './errors.js';
+import { SignalRegistry } from './signals.js';
+// Bound a single connect/auth attempt so a stalled handshake cannot freeze the reconnect
+// loop. A local unix-socket D-Bus connect completes in milliseconds; 2s is ample headroom
+// while keeping reconnect responsive after a bus restart.
+const CONNECT_TIMEOUT_MS = 2_000;
+const DEFAULT_RECONNECT = {
+    enabled: true,
+    initialDelayMs: 50,
+    maxDelayMs: 2_000,
+    maxAttempts: 0,
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class DbusTransportImpl {
+    #options;
+    #reconnect;
+    #emitter = new EventEmitter();
+    #calls;
+    #signals;
+    #bus = null;
+    #state = 'idle';
+    #closing = false;
+    // Bound once so the same references can be detached from a dead connection.
+    #onMessage = (message) => this.#signals.dispatch(message);
+    #onConnectionError = (cause) => this.#handleDrop(cause instanceof Error ? cause : new DisconnectedError(String(cause)));
+    #onConnectionEnd = () => this.#handleDrop(new DisconnectedError('bus connection ended'));
+    constructor(options) {
+        this.#options = options;
+        this.#calls = new CallDispatcher(options.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS);
+        this.#signals = new SignalRegistry({
+            currentBus: () => this.#bus,
+            isConnected: () => this.#state === 'connected',
+            emitError: (error) => this.#emitter.emit('error', error),
+        });
+        this.#reconnect = {
+            enabled: options.reconnect?.enabled ?? DEFAULT_RECONNECT.enabled,
+            initialDelayMs: options.reconnect?.initialDelayMs ?? DEFAULT_RECONNECT.initialDelayMs,
+            maxDelayMs: options.reconnect?.maxDelayMs ?? DEFAULT_RECONNECT.maxDelayMs,
+            maxAttempts: options.reconnect?.maxAttempts ?? DEFAULT_RECONNECT.maxAttempts,
+        };
+        // Avoid MaxListeners warnings when many consumers observe transport events.
+        this.#emitter.setMaxListeners(0);
+    }
+    async connect() {
+        if (this.#state === 'connected') {
+            return;
+        }
+        if (this.#closing) {
+            throw new TransportError('Transport is closed');
+        }
+        this.#state = 'connecting';
+        await this.#establish();
+        this.#emitter.emit('connected');
+    }
+    isConnected() {
+        return this.#state === 'connected';
+    }
+    async disconnect() {
+        this.#closing = true;
+        this.#state = 'closed';
+        const bus = this.#bus;
+        this.#bus = null;
+        this.#calls.rejectAll(new DisconnectedError('transport closed'));
+        if (bus) {
+            this.#quiesce(bus);
+            await bus.disconnect().catch(() => undefined);
+        }
+    }
+    callMethod(call) {
+        return this.#calls.call(this.#bus, this.#state === 'connected', call);
+    }
+    subscribeSignal(spec, listener) {
+        return this.#signals.subscribe(spec, listener);
+    }
+    subscriptionCount() {
+        return this.#signals.count();
+    }
+    on(event, handler) {
+        this.#emitter.on(event, handler);
+    }
+    off(event, handler) {
+        this.#emitter.off(event, handler);
+    }
+    // ── internals ──────────────────────────────────────────────────────────────────
+    async #establish() {
+        const options = { ReturnLongjs: true };
+        if (this.#options.socket !== undefined) {
+            options.socket = this.#options.socket;
+        }
+        else if (this.#options.busAddress !== undefined) {
+            options.busAddress = this.#options.busAddress;
+        }
+        const bus = createClient(options);
+        try {
+            await new Promise((resolve, reject) => {
+                const onConnect = () => {
+                    cleanup();
+                    resolve();
+                };
+                const onError = (error) => {
+                    cleanup();
+                    reject(error instanceof Error ? error : new TransportError(String(error)));
+                };
+                const timer = setTimeout(() => {
+                    cleanup();
+                    reject(new TransportError(`bus connect timed out after ${CONNECT_TIMEOUT_MS}ms`));
+                }, CONNECT_TIMEOUT_MS);
+                const cleanup = () => {
+                    clearTimeout(timer);
+                    bus.connection.removeListener('connect', onConnect);
+                    bus.connection.removeListener('error', onError);
+                };
+                bus.connection.once('connect', onConnect);
+                bus.connection.once('error', onError);
+            });
+            bus.connection.on('message', this.#onMessage);
+            bus.connection.on('error', this.#onConnectionError);
+            bus.connection.on('end', this.#onConnectionEnd);
+            // Re-issue every live match rule so a reconnect resubscribes transparently.
+            await this.#signals.reissueRules(bus);
+            this.#bus = bus;
+            this.#state = 'connected';
+        }
+        catch (error) {
+            this.#detachHandlers(bus);
+            bus.connection.removeAllListeners();
+            bus.connection.on('error', () => undefined);
+            try {
+                bus.connection.end();
+            }
+            catch {
+                // The half-open connection is already dead; nothing to close.
+            }
+            throw error;
+        }
+    }
+    #detachHandlers(bus) {
+        bus.connection.removeListener('message', this.#onMessage);
+        bus.connection.removeListener('error', this.#onConnectionError);
+        bus.connection.removeListener('end', this.#onConnectionEnd);
+    }
+    // Detach our handlers from a dead connection, then swallow any late socket error it
+    // still emits — without a listener, Node re-throws an EventEmitter 'error' and crashes
+    // the process mid-reconnect.
+    #quiesce(bus) {
+        this.#detachHandlers(bus);
+        bus.connection.on('error', () => undefined);
+    }
+    #handleDrop(cause) {
+        if (this.#closing) {
+            return;
+        }
+        if (this.#state === 'disconnected' || this.#state === 'reconnecting') {
+            return;
+        }
+        this.#state = 'disconnected';
+        if (this.#bus) {
+            this.#quiesce(this.#bus);
+        }
+        this.#bus = null;
+        this.#calls.rejectAll(cause);
+        this.#emitter.emit('disconnected', cause);
+        if (this.#reconnect.enabled) {
+            void this.#reconnectLoop();
+        }
+    }
+    async #reconnectLoop() {
+        this.#state = 'reconnecting';
+        let delay = this.#reconnect.initialDelayMs;
+        let attempt = 0;
+        while (!this.#closing) {
+            attempt += 1;
+            try {
+                await this.#establish();
+                this.#emitter.emit('reconnected');
+                return;
+            }
+            catch (error) {
+                if (this.#reconnect.maxAttempts > 0 && attempt >= this.#reconnect.maxAttempts) {
+                    this.#state = 'disconnected';
+                    this.#emitter.emit('error', error);
+                    return;
+                }
+                await sleep(delay);
+                delay = Math.min(delay * 2, this.#reconnect.maxDelayMs);
+            }
+        }
+    }
+}
+export function createDbusTransport(options = {}) {
+    return new DbusTransportImpl(options);
+}

package/dist/transport/types.d.ts

@@ -0,0 +1,61 @@
+export type DbusValue = string | number | boolean | bigint | Uint8Array | DbusVariant | DbusValue[];
+export interface DbusVariant {
+    readonly signature: string;
+    readonly value: DbusValue;
+}
+export declare function variant(signature: string, value: DbusValue): DbusVariant;
+export declare function isVariant(value: DbusValue): value is DbusVariant;
+export interface MethodCall {
+    readonly destination: string;
+    readonly path: string;
+    readonly interface: string;
+    readonly member: string;
+    readonly signature?: string;
+    readonly args?: readonly DbusValue[];
+    readonly timeoutMs?: number;
+}
+export interface MethodReply {
+    readonly signature: string;
+    readonly body: DbusValue[];
+}
+export interface SignalSpec {
+    readonly interface: string;
+    readonly member: string;
+    readonly path?: string;
+    readonly sender?: string;
+}
+export interface SignalEvent {
+    readonly path: string;
+    readonly interface: string;
+    readonly member: string;
+    readonly sender: string | undefined;
+    readonly signature: string;
+    readonly body: DbusValue[];
+}
+export type SignalListener = (event: SignalEvent) => void;
+export interface Subscription {
+    unsubscribe(): Promise<void>;
+}
+export type TransportEvent = 'connected' | 'reconnected' | 'disconnected' | 'error';
+export interface DbusTransportOptions {
+    readonly busAddress?: string;
+    readonly socket?: string;
+    readonly callTimeoutMs?: number;
+    readonly reconnect?: ReconnectOptions;
+}
+export interface ReconnectOptions {
+    readonly enabled?: boolean;
+    readonly initialDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly maxAttempts?: number;
+}
+export interface DbusTransport {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    callMethod(call: MethodCall): Promise<MethodReply>;
+    subscribeSignal(spec: SignalSpec, listener: SignalListener): Promise<Subscription>;
+    on(event: TransportEvent, handler: (payload?: unknown) => void): void;
+    off(event: TransportEvent, handler: (payload?: unknown) => void): void;
+    subscriptionCount(): number;
+}

package/dist/transport/types.js

@@ -0,0 +1,19 @@
+// Public value and message types for the D-Bus transport seam.
+//
+// These types are the transport's own vocabulary. None of the underlying
+// `@httptoolkit/dbus-native` types appear here or in `./index.ts`, so the package's
+// public surface never leaks the library — swapping the implementation (see README:
+// documented fallback `@particle/dbus-next`) would not change a single caller type.
+// Construct a variant for encoding, e.g. `variant('u', 42)` or `variant('t', 5n)`.
+export function variant(signature, value) {
+    return { signature, value };
+}
+// Narrowing guard for a decoded variant.
+export function isVariant(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Uint8Array) &&
+        typeof value.signature === 'string' &&
+        'value' in value);
+}

package/dist/usb-mode/catalog-schema.d.ts

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+/**
+ * The full canonical USB composition-mode vocabulary. A SKU's `canonicalMode` may be
+ * any of these; only the first three are ModemManager-manageable. (Structurally
+ * identical to `PreferredUsbMode` in the power contract — A4.2 owns this vocabulary.)
+ */
+export declare const CANONICAL_USB_MODES: readonly ["qmi", "mbim", "ecm-ncm", "rndis", "router-ethernet"];
+export type CanonicalUsbMode = (typeof CANONICAL_USB_MODES)[number];
+/**
+ * The ModemManager-manageable modes — the ONLY modes a transition may move between.
+ * `rndis` and `router-ethernet` are deliberately absent: a device in either is not
+ * MM-managed, so switching to/from them crosses the MM↔router line the schema forbids.
+ */
+export declare const MM_USB_MODES: readonly ["qmi", "mbim", "ecm-ncm"];
+export type MmUsbMode = (typeof MM_USB_MODES)[number];
+/** The USB descriptors a device must present AFTER a transition — the postcondition. */
+export declare const expectedDescriptorsSchema: z.ZodObject<{
+    deviceClass: z.ZodNumber;
+    interfaces: z.ZodArray<z.ZodObject<{
+        interfaceClass: z.ZodNumber;
+        interfaceSubClass: z.ZodNumber;
+        interfaceProtocol: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ExpectedDescriptors = z.infer<typeof expectedDescriptorsSchema>;
+/** One permitted, certified transition between two MM modes. */
+export declare const permittedTransitionSchema: z.ZodObject<{
+    from: z.ZodEnum<{
+        qmi: "qmi";
+        mbim: "mbim";
+        "ecm-ncm": "ecm-ncm";
+    }>;
+    to: z.ZodEnum<{
+        qmi: "qmi";
+        mbim: "mbim";
+        "ecm-ncm": "ecm-ncm";
+    }>;
+    atCommand: z.ZodString;
+    applyCommand: z.ZodOptional<z.ZodString>;
+    expectedResponse: z.ZodString;
+    expectsPortDrop: z.ZodBoolean;
+    expectedDescriptors: z.ZodObject<{
+        deviceClass: z.ZodNumber;
+        interfaces: z.ZodArray<z.ZodObject<{
+            interfaceClass: z.ZodNumber;
+            interfaceSubClass: z.ZodNumber;
+            interfaceProtocol: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    evidenceBundleSha256: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PermittedTransition = z.infer<typeof permittedTransitionSchema>;
+/** One certified SKU: its discriminator, canonical mode, and permitted transitions. */
+export declare const catalogEntrySchema: z.ZodObject<{
+    vidPid: z.ZodString;
+    model: z.ZodString;
+    firmwarePrefix: z.ZodString;
+    canonicalMode: z.ZodEnum<{
+        qmi: "qmi";
+        mbim: "mbim";
+        "ecm-ncm": "ecm-ncm";
+        rndis: "rndis";
+        "router-ethernet": "router-ethernet";
+    }>;
+    permittedTransitions: z.ZodArray<z.ZodObject<{
+        from: z.ZodEnum<{
+            qmi: "qmi";
+            mbim: "mbim";
+            "ecm-ncm": "ecm-ncm";
+        }>;
+        to: z.ZodEnum<{
+            qmi: "qmi";
+            mbim: "mbim";
+            "ecm-ncm": "ecm-ncm";
+        }>;
+        atCommand: z.ZodString;
+        applyCommand: z.ZodOptional<z.ZodString>;
+        expectedResponse: z.ZodString;
+        expectsPortDrop: z.ZodBoolean;
+        expectedDescriptors: z.ZodObject<{
+            deviceClass: z.ZodNumber;
+            interfaces: z.ZodArray<z.ZodObject<{
+                interfaceClass: z.ZodNumber;
+                interfaceSubClass: z.ZodNumber;
+                interfaceProtocol: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        evidenceBundleSha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CatalogEntry = z.infer<typeof catalogEntrySchema>;
+/** The whole certified catalog file. */
+export declare const certifiedCatalogSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    entries: z.ZodArray<z.ZodObject<{
+        vidPid: z.ZodString;
+        model: z.ZodString;
+        firmwarePrefix: z.ZodString;
+        canonicalMode: z.ZodEnum<{
+            qmi: "qmi";
+            mbim: "mbim";
+            "ecm-ncm": "ecm-ncm";
+            rndis: "rndis";
+            "router-ethernet": "router-ethernet";
+        }>;
+        permittedTransitions: z.ZodArray<z.ZodObject<{
+            from: z.ZodEnum<{
+                qmi: "qmi";
+                mbim: "mbim";
+                "ecm-ncm": "ecm-ncm";
+            }>;
+            to: z.ZodEnum<{
+                qmi: "qmi";
+                mbim: "mbim";
+                "ecm-ncm": "ecm-ncm";
+            }>;
+            atCommand: z.ZodString;
+            applyCommand: z.ZodOptional<z.ZodString>;
+            expectedResponse: z.ZodString;
+            expectsPortDrop: z.ZodBoolean;
+            expectedDescriptors: z.ZodObject<{
+                deviceClass: z.ZodNumber;
+                interfaces: z.ZodArray<z.ZodObject<{
+                    interfaceClass: z.ZodNumber;
+                    interfaceSubClass: z.ZodNumber;
+                    interfaceProtocol: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            evidenceBundleSha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CertifiedCatalog = z.infer<typeof certifiedCatalogSchema>;
+/** A live device's SKU discriminator — matched against the catalog. */
+export interface SkuDiscriminator {
+    readonly vidPid: string;
+    readonly model: string;
+    readonly firmwarePrefix: string;
+}