@ceralive/modem-control 1.0.0 → 1.2.0

package/dist/providers/huawei-hilink/operations.d.ts

@@ -0,0 +1,20 @@
+import type { DeviceGeneration, OperationDescriptor, OperationResult } from '../../domain/index.js';
+import type { ProviderExecutionContext } from '../contracts.js';
+import { type HilinkProfile } from './provider.js';
+export type ReadValue = Readonly<Record<string, unknown>>;
+export type ReadOperation = {
+    readonly descriptor: OperationDescriptor<never, ReadValue>;
+    readonly read: (context: ProviderExecutionContext) => Promise<OperationResult<ReadValue>>;
+};
+export type WriteOperation = {
+    readonly descriptor: OperationDescriptor<string | boolean, ReadValue>;
+    readonly read: ReadOperation['read'];
+    readonly write: (context: ProviderExecutionContext, value: string | boolean) => Promise<OperationResult<ReadValue>>;
+};
+export declare function applied(generation: DeviceGeneration, value: ReadValue): OperationResult<ReadValue>;
+export declare function refused(generation: DeviceGeneration, reason: string): OperationResult<ReadValue>;
+export declare function operationDescriptor<I>(id: string, write: boolean, profile: HilinkProfile): OperationDescriptor<I, ReadValue>;
+export declare function requestSucceeded(status: number, body: string): boolean;
+export declare function capabilityPath(kind: 'status' | 'signal' | 'mode' | 'data'): string;
+export declare function writeDocument(kind: 'mode' | 'data', value: string | boolean): string;
+export declare function readbackMatches(kind: 'mode' | 'data', body: string, value: string | boolean): boolean;

package/dist/providers/huawei-hilink/operations.js

@@ -0,0 +1,56 @@
+import { defineOperationDescriptor } from '../../domain/index.js';
+import { parseHilinkDataCapability, parseHilinkXmlValue } from '../../hardware/router-parsers.js';
+import { HILINK_PATHS } from './provider.js';
+export function applied(generation, value) {
+    return { status: 'applied', value, generation, requiresReconciliation: false };
+}
+export function refused(generation, reason) {
+    return { status: 'refused', reason, generation, requiresReconciliation: false };
+}
+export function operationDescriptor(id, write, profile) {
+    return defineOperationDescriptor({
+        id,
+        support: {
+            read: { supported: true },
+            write: write ? { supported: true } : { supported: false, reason: 'read-only' },
+        },
+        authority: 'provider',
+        provider: 'huawei-hilink',
+        constraints: { kind: 'unconstrained' },
+        livePreconditions: ['fresh-session', 'capability-evidence'],
+        availability: { state: 'available' },
+        mutationImpact: write ? 'write' : 'read',
+        retryClass: 'never',
+        readback: write
+            ? { required: true, reason: 'fresh-readback', matches: () => true }
+            : { required: false },
+        rollback: { required: false },
+        journal: { required: false },
+        admission: { required: true, reason: 'router-session' },
+        evidence: { profiles: [profile.id], firmware: [profile.firmware] },
+        confidence: 'high',
+    });
+}
+export function requestSucceeded(status, body) {
+    return status >= 200 && status < 300 && /<response>\s*OK\s*<\/response>/i.test(body);
+}
+export function capabilityPath(kind) {
+    return kind === 'status'
+        ? HILINK_PATHS.status
+        : kind === 'signal'
+            ? HILINK_PATHS.signal
+            : kind === 'mode'
+                ? HILINK_PATHS.modeList
+                : HILINK_PATHS.data;
+}
+export function writeDocument(kind, value) {
+    return kind === 'mode'
+        ? `<?xml version="1.0" encoding="UTF-8"?><request><NetworkMode>${String(value)}</NetworkMode></request>`
+        : `<?xml version="1.0" encoding="UTF-8"?><request><dataswitch>${value ? 1 : 0}</dataswitch></request>`;
+}
+export function readbackMatches(kind, body, value) {
+    if (kind === 'mode')
+        return parseHilinkXmlValue(body, 'NetworkMode') === String(value);
+    const parsed = parseHilinkDataCapability(body);
+    return parsed.state === 'reported' && parsed.enabled === Boolean(value);
+}

package/dist/providers/huawei-hilink/provider.d.ts

@@ -0,0 +1,52 @@
+import type { NormalizedModemObservation } from '../../observations/index.js';
+import type { ResourceOwnershipPort } from '../../ports/resource-ownership.js';
+import type { ProviderDefinition, ProviderOperationsSurface } from '../contracts.js';
+import { HuaweiProvider, type ReadOperation, type WriteOperation } from './runtime.js';
+import type { HilinkTransport } from './transport.js';
+export declare const HILINK_PATHS: {
+    readonly session: '/api/webserver/SesTokInfo';
+    readonly loginState: '/api/user/state-login';
+    readonly login: '/api/user/login';
+    readonly status: '/api/monitoring/status';
+    readonly signal: '/api/device/signal';
+    readonly modeList: '/api/net/net-mode-list';
+    readonly mode: '/api/net/net-mode';
+    readonly data: '/api/dialup/mobile-dataswitch';
+};
+export type HilinkProfile = {
+    readonly id: string;
+    readonly firmware: string;
+    readonly passwordType: 3 | 4;
+};
+export declare const HILINK_PROFILES: readonly [{
+    readonly id: 'e3372h-22.200-password-type-3';
+    readonly firmware: '22.200.05.00.1080';
+    readonly passwordType: 3;
+}, {
+    readonly id: 'e3372h-22.333-password-type-4';
+    readonly firmware: '22.333.01.00.00';
+    readonly passwordType: 4;
+}];
+export type HilinkCredentials = {
+    readonly username: string;
+    readonly password: string;
+};
+export type HilinkOptions = {
+    readonly interfaceName: string;
+    readonly adminUrl: string;
+    readonly transport: HilinkTransport;
+    readonly ownership: ResourceOwnershipPort;
+    readonly credentials: HilinkCredentials;
+    readonly now?: () => number;
+};
+export type HilinkObservation = NormalizedModemObservation;
+export type HuaweiOperations = ProviderOperationsSurface & {
+    readonly status: ReadOperation;
+    readonly signal: ReadOperation;
+    readonly mode: WriteOperation;
+    readonly data: WriteOperation;
+};
+export declare function hilinkProfile(profileId: string): HilinkProfile | undefined;
+export declare function createHuaweiHiLinkProvider(options: HilinkOptions): HuaweiProvider;
+export declare function createHuaweiHiLinkDefinition(options: HilinkOptions): ProviderDefinition<HilinkObservation, HuaweiOperations>;
+export { HuaweiProvider as HuaweiHiLinkProvider };

package/dist/providers/huawei-hilink/provider.js

@@ -0,0 +1,76 @@
+import { HuaweiProvider } from './runtime.js';
+export const HILINK_PATHS = {
+    session: '/api/webserver/SesTokInfo',
+    loginState: '/api/user/state-login',
+    login: '/api/user/login',
+    status: '/api/monitoring/status',
+    signal: '/api/device/signal',
+    modeList: '/api/net/net-mode-list',
+    mode: '/api/net/net-mode',
+    data: '/api/dialup/mobile-dataswitch',
+};
+export const HILINK_PROFILES = [
+    {
+        id: 'e3372h-22.200-password-type-3',
+        firmware: '22.200.05.00.1080',
+        passwordType: 3,
+    },
+    {
+        id: 'e3372h-22.333-password-type-4',
+        firmware: '22.333.01.00.00',
+        passwordType: 4,
+    },
+];
+export function hilinkProfile(profileId) {
+    return HILINK_PROFILES.find((profile) => profile.id === profileId);
+}
+export function createHuaweiHiLinkProvider(options) {
+    return new HuaweiProvider(options);
+}
+export function createHuaweiHiLinkDefinition(options) {
+    const runtime = createHuaweiHiLinkProvider(options);
+    return {
+        id: 'huawei-hilink',
+        profileVersion: '1',
+        eligibleTransports: ['network'],
+        passiveMatchers: HILINK_PROFILES.map((profile) => ({
+            id: `firmware-${profile.firmware}`,
+            fact: 'firmware',
+            expected: [profile.firmware],
+            profiles: [profile.id],
+            strength: 'strong',
+            required: true,
+        })),
+        unauthenticatedProbes: [
+            {
+                id: 'hilink-session-shape',
+                run: (request) => runtime.sessionProbe(request),
+            },
+        ],
+        authenticatedProfile: {
+            algorithm: 'firmware-selected-hilink-password',
+            attemptLimit: 1,
+            authenticate: (request, candidates) => runtime.authenticateProfile(request, candidates),
+        },
+        capabilityReaders: [
+            runtime.capability('status'),
+            runtime.capability('signal'),
+            runtime.capability('mode'),
+            runtime.capability('data'),
+        ],
+        observe: (context) => runtime.observe(context),
+        operations: (profile) => runtime.operations(profile),
+        contractFixtures: HILINK_PROFILES.map((profile) => ({
+            profile: profile.id,
+            request: {
+                method: 'POST',
+                path: HILINK_PATHS.login,
+                passwordType: profile.passwordType,
+                interfaceBound: true,
+                redirects: 'disabled',
+            },
+            response: { status: 'matched', sessionMaterial: '[redacted]' },
+        })),
+    };
+}
+export { HuaweiProvider as HuaweiHiLinkProvider };

package/dist/providers/huawei-hilink/runtime.d.ts

@@ -0,0 +1,22 @@
+import type { ObservationEnvelope } from '../../domain/index.js';
+import type { AuthenticatedProfileResult, CapabilityReader, ProviderExecutionContext, ProviderMatchRequest } from '../contracts.js';
+import { type HilinkObservation, type HuaweiOperations } from './provider.js';
+import { HilinkSessionRuntime } from './session.js';
+export type { ReadOperation, WriteOperation } from './operations.js';
+export declare class HuaweiProvider extends HilinkSessionRuntime {
+    sessionProbe(request: ProviderMatchRequest): Promise<{
+        signal: "match" | "unknown";
+        strength: 'strong';
+        profiles: ("e3372h-22.200-password-type-3" | "e3372h-22.333-password-type-4")[];
+        detail: string;
+    }>;
+    authenticateProfile(request: ProviderMatchRequest, candidates: readonly string[]): Promise<AuthenticatedProfileResult>;
+    observe(context: ProviderExecutionContext): Promise<readonly ObservationEnvelope<HilinkObservation>[]>;
+    capability(kind: 'status' | 'signal' | 'mode' | 'data'): CapabilityReader;
+    operations(profileId: string): HuaweiOperations;
+    private sessionFor;
+    private capabilitySupported;
+    private readOperation;
+    private writeOperation;
+    private write;
+}

package/dist/providers/huawei-hilink/runtime.js

@@ -0,0 +1,171 @@
+import { parseHilinkCapabilities, parseHilinkDataCapability, parseHilinkSession, parseHilinkXmlValue, } from '../../hardware/router-parsers.js';
+import { normalizeHilinkObservation } from '../../observations/sources/hilink.js';
+import { applied, capabilityPath, operationDescriptor, readbackMatches, refused, requestSucceeded, writeDocument, } from './operations.js';
+import { HILINK_PATHS, HILINK_PROFILES, hilinkProfile, } from './provider.js';
+import { HilinkSessionRuntime } from './session.js';
+export class HuaweiProvider extends HilinkSessionRuntime {
+    async sessionProbe(request) {
+        const profile = HILINK_PROFILES.find((candidate) => candidate.firmware === request.firmware);
+        const response = await this.request('GET', HILINK_PATHS.session);
+        const matches = response.status === 200 && parseHilinkSession(response.body) !== undefined;
+        return {
+            signal: matches && profile !== undefined ? 'match' : 'unknown',
+            strength: 'strong',
+            profiles: profile === undefined ? [] : [profile.id],
+            detail: matches ? 'session-token-evidence' : 'session-token-not-proven',
+        };
+    }
+    async authenticateProfile(request, candidates) {
+        const candidate = candidates.length === 1 ? hilinkProfile(candidates[0] ?? '') : undefined;
+        if (candidate === undefined)
+            return { status: 'refused', detail: 'profile-mismatch' };
+        const result = await this.authenticate(request, candidate, true);
+        if (result.status === 'ready')
+            return { status: 'matched', profile: candidate.id, detail: 'login-ok' };
+        return {
+            status: result.reason === 'unreachable' ? 'unavailable' : 'refused',
+            detail: result.reason,
+        };
+    }
+    async observe(context) {
+        const ready = await this.sessionFor(context);
+        if (ready === undefined)
+            return [];
+        const [status, signal, modeList, mode] = await Promise.all([
+            this.getResponse(HILINK_PATHS.status, ready),
+            this.getResponse(HILINK_PATHS.signal, ready),
+            this.getResponse(HILINK_PATHS.modeList, ready),
+            this.getResponse(HILINK_PATHS.mode, ready),
+        ]);
+        const input = {
+            status: status.body,
+            signal: signal.body,
+            netModeList: modeList.body,
+            netMode: mode.body,
+        };
+        return [
+            normalizeHilinkObservation(input, {
+                stableKey: `modem:${this.options.interfaceName}`,
+                generation: context.generation,
+                sourceEpoch: 1,
+                observedAt: (this.options.now?.() ?? Date.now()),
+            }),
+        ];
+    }
+    capability(kind) {
+        return {
+            id: `hilink-${kind}`,
+            read: async (context) => {
+                const session = await this.sessionFor(context);
+                if (session === undefined)
+                    return { signal: 'unknown', strength: 'strong', detail: 'session-unavailable' };
+                const path = capabilityPath(kind);
+                const response = await this.getResponse(path, session);
+                const supported = this.capabilitySupported(kind, response.body) && !this.authExpired(response);
+                return {
+                    signal: supported ? 'match' : 'mismatch',
+                    strength: 'strong',
+                    detail: supported ? 'capability-reported' : 'capability-refused',
+                };
+            },
+        };
+    }
+    operations(profileId) {
+        const profile = hilinkProfile(profileId);
+        if (profile === undefined)
+            return unsupportedOperations(profileId);
+        return {
+            access: 'read-write',
+            status: this.readOperation('status', HILINK_PATHS.status, profile),
+            signal: this.readOperation('signal', HILINK_PATHS.signal, profile),
+            mode: this.writeOperation('mode', HILINK_PATHS.mode, profile),
+            data: this.writeOperation('data', HILINK_PATHS.data, profile),
+        };
+    }
+    async sessionFor(context) {
+        const cached = this.cachedSession(context);
+        if (cached !== undefined)
+            return cached;
+        const profile = hilinkProfile(context.profile);
+        if (profile === undefined)
+            return undefined;
+        const result = await this.authenticate(context, profile, true);
+        return result.status === 'ready' ? result.session : undefined;
+    }
+    capabilitySupported(kind, body) {
+        if (kind === 'mode')
+            return parseHilinkCapabilities({ netModeList: body }).net_mode.state === 'reported';
+        if (kind === 'data')
+            return parseHilinkDataCapability(body).state === 'reported';
+        return parseHilinkXmlValue(body, 'code') === undefined && /<response>/i.test(body);
+    }
+    readOperation(id, path, profile) {
+        return {
+            descriptor: operationDescriptor(id, false, profile),
+            read: async (context) => {
+                const result = await this.authenticate(context, profile, false);
+                if (result.status === 'refused')
+                    return refused(context.generation, result.reason);
+                const response = await this.getResponse(path, result.session);
+                if (this.authExpired(response))
+                    return refused(context.generation, 'auth-expired');
+                if (response.status < 200 || response.status >= 300)
+                    return refused(context.generation, 'http-failure');
+                return applied(context.generation, { body: response.body });
+            },
+        };
+    }
+    writeOperation(id, path, profile) {
+        return {
+            descriptor: operationDescriptor(id, true, profile),
+            read: this.readOperation(`${id}-read`, path, profile).read,
+            write: (context, value) => this.write(context, profile, id, path, value),
+        };
+    }
+    async write(context, profile, kind, path, value) {
+        return this.withDevice(context, async () => {
+            const ownership = await this.options.ownership.acquire({ resource: 'router-session' });
+            if (ownership.status === 'refused')
+                return refused(context.generation, 'busy');
+            try {
+                const ready = await this.authenticate(context, profile, false);
+                if (ready.status === 'refused')
+                    return refused(context.generation, ready.reason);
+                const capabilityPath = kind === 'mode' ? HILINK_PATHS.modeList : HILINK_PATHS.data;
+                const capability = await this.getResponse(capabilityPath, ready.session);
+                if (this.authExpired(capability))
+                    return refused(context.generation, 'auth-expired');
+                if (!this.capabilitySupported(kind, capability.body))
+                    return refused(context.generation, 'capability-unavailable');
+                if (kind === 'mode') {
+                    const offered = parseHilinkCapabilities({ netModeList: capability.body }).net_mode;
+                    if (offered.state !== 'reported' ||
+                        !offered.modes.some((mode) => mode.id === String(value)))
+                        return refused(context.generation, 'capability-unavailable');
+                }
+                const body = writeDocument(kind, value);
+                const posted = await this.postResponse(path, body, ready.session);
+                if (this.authExpired(posted))
+                    return refused(context.generation, 'auth-expired');
+                if (!requestSucceeded(posted.status, posted.body))
+                    return refused(context.generation, 'http-failure');
+                const fresh = await this.authenticate(context, profile, false);
+                if (fresh.status === 'refused')
+                    return refused(context.generation, fresh.reason);
+                const readback = await this.getResponse(path, fresh.session);
+                if (this.authExpired(readback))
+                    return refused(context.generation, 'auth-expired');
+                const matches = readbackMatches(kind, readback.body, value);
+                return matches
+                    ? applied(context.generation, { body: readback.body })
+                    : refused(context.generation, 'not-applied');
+            }
+            finally {
+                await ownership.lease.release();
+            }
+        });
+    }
+}
+function unsupportedOperations(_profileId) {
+    throw new Error('unsupported-hilink-profile');
+}

package/dist/providers/huawei-hilink/session.d.ts

@@ -0,0 +1,28 @@
+import type { ProviderExecutionContext, ProviderMatchRequest } from '../contracts.js';
+import { type HilinkOptions, type HilinkProfile } from './provider.js';
+import type { HilinkHttpResponse } from './transport.js';
+export type HilinkSession = {
+    readonly cookie: string;
+    readonly token: string;
+};
+export type HilinkSessionFailure = 'auth-expired' | 'http-failure' | 'malformed' | 'profile-mismatch' | 'unreachable';
+export type HilinkSessionResult = {
+    readonly status: 'ready';
+    readonly session: HilinkSession;
+} | {
+    readonly status: 'refused';
+    readonly reason: HilinkSessionFailure;
+};
+export declare class HilinkSessionRuntime {
+    #private;
+    protected readonly options: HilinkOptions;
+    constructor(options: HilinkOptions);
+    protected withDevice<T>(context: ProviderExecutionContext, run: () => Promise<T>): Promise<T>;
+    protected sessionKey(context: ProviderMatchRequest): string;
+    protected cachedSession(context: ProviderMatchRequest): HilinkSession | undefined;
+    protected authenticate(context: ProviderMatchRequest, profile: HilinkProfile, cache: boolean): Promise<HilinkSessionResult>;
+    protected authExpired(response: HilinkHttpResponse): boolean;
+    protected getResponse(path: string, session: HilinkSession): Promise<HilinkHttpResponse>;
+    protected postResponse(path: string, body: string, session: HilinkSession): Promise<HilinkHttpResponse>;
+    protected request(method: 'GET' | 'POST', path: string, body?: string, headers?: readonly string[]): Promise<HilinkHttpResponse>;
+}

package/dist/providers/huawei-hilink/session.js

@@ -0,0 +1,120 @@
+import { createHash } from 'node:crypto';
+import { parseHilinkSession, parseHilinkUserState, parseHilinkXmlValue, } from '../../hardware/router-parsers.js';
+import { HILINK_PATHS } from './provider.js';
+function base64(value) {
+    return Buffer.from(value).toString('base64');
+}
+function derivePassword(profile, username, password, token) {
+    if (profile.passwordType === 3)
+        return base64(password);
+    const passwordHash = base64(createHash('sha256').update(password).digest('hex'));
+    const loginHash = createHash('sha256').update(`${username}${passwordHash}${token}`).digest('hex');
+    return base64(loginHash);
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function loginDocument(profile, username, password, token) {
+    return `<?xml version="1.0" encoding="UTF-8"?><request><Username>${escapeXml(username)}</Username><Password>${derivePassword(profile, username, password, token)}</Password><password_type>${profile.passwordType}</password_type></request>`;
+}
+function responseHeader(response, name) {
+    const expected = name.toLowerCase();
+    return Object.entries(response.headers ?? {}).find(([key]) => key.toLowerCase() === expected)?.[1];
+}
+function loggedInSession(response, fallback) {
+    const cookie = responseHeader(response, 'set-cookie')?.split(';', 1)[0]?.trim() ?? fallback.cookie;
+    const tokenHeader = responseHeader(response, '__requestverificationtoken') ??
+        responseHeader(response, '__requestverificationtokenone');
+    const token = tokenHeader?.split('#', 1)[0]?.trim() ?? fallback.token;
+    return { cookie, token };
+}
+export class HilinkSessionRuntime {
+    options;
+    #authenticated = new Map();
+    #serial = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async withDevice(context, run) {
+        const key = String(context.physicalModemId);
+        const prior = this.#serial.get(key) ?? Promise.resolve();
+        let release = () => { };
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const chain = prior.then(() => current);
+        this.#serial.set(key, chain);
+        await prior;
+        try {
+            return await run();
+        }
+        finally {
+            release();
+            if (this.#serial.get(key) === chain)
+                this.#serial.delete(key);
+        }
+    }
+    sessionKey(context) {
+        return `${context.physicalModemId}:${context.generation}`;
+    }
+    cachedSession(context) {
+        return this.#authenticated.get(this.sessionKey(context));
+    }
+    async authenticate(context, profile, cache) {
+        const sessionResponse = await this.request('GET', HILINK_PATHS.session);
+        if (sessionResponse.status === 401 || sessionResponse.status === 403)
+            return { status: 'refused', reason: 'auth-expired' };
+        if (sessionResponse.status !== 200)
+            return { status: 'refused', reason: 'unreachable' };
+        const initial = parseHilinkSession(sessionResponse.body);
+        if (initial === undefined)
+            return { status: 'refused', reason: 'malformed' };
+        const stateResponse = await this.getResponse(HILINK_PATHS.loginState, initial);
+        if (this.authExpired(stateResponse))
+            return { status: 'refused', reason: 'auth-expired' };
+        const state = parseHilinkUserState(stateResponse.body);
+        if (state === undefined)
+            return { status: 'refused', reason: 'malformed' };
+        if (state.passwordType !== profile.passwordType)
+            return { status: 'refused', reason: 'profile-mismatch' };
+        const login = await this.postResponse(HILINK_PATHS.login, loginDocument(profile, this.options.credentials.username, this.options.credentials.password, initial.token), initial);
+        if (this.authExpired(login))
+            return { status: 'refused', reason: 'auth-expired' };
+        if (login.status !== 200 || !/<response>\s*OK\s*<\/response>/i.test(login.body))
+            return { status: 'refused', reason: 'http-failure' };
+        const session = loggedInSession(login, initial);
+        if (cache)
+            this.#authenticated.set(this.sessionKey(context), session);
+        return { status: 'ready', session };
+    }
+    authExpired(response) {
+        return (response.status === 401 ||
+            response.status === 403 ||
+            parseHilinkXmlValue(response.body, 'code') === '125002');
+    }
+    getResponse(path, session) {
+        return this.request('GET', path, undefined, [`Cookie: ${session.cookie}`]);
+    }
+    postResponse(path, body, session) {
+        return this.request('POST', path, body, [
+            `Cookie: ${session.cookie}`,
+            `__RequestVerificationToken: ${session.token}`,
+            'Content-Type: application/xml',
+        ]);
+    }
+    request(method, path, body, headers = []) {
+        return this.options.transport.request({
+            method,
+            url: `${this.options.adminUrl}${path}`,
+            ...(body === undefined ? {} : { body }),
+            headers,
+            interfaceName: this.options.interfaceName,
+            redirect: 'error',
+        });
+    }
+}

package/dist/providers/huawei-hilink/transport.d.ts

@@ -0,0 +1,19 @@
+export type HilinkHttpRequest = {
+    readonly method: 'GET' | 'POST';
+    readonly url: string;
+    readonly body?: string;
+    readonly headers: readonly string[];
+    readonly interfaceName: string;
+    readonly redirect: 'error';
+};
+export type HilinkHttpResponse = {
+    readonly status: number;
+    readonly body: string;
+    readonly headers?: Readonly<Record<string, string>>;
+};
+export interface HilinkTransport {
+    request(request: HilinkHttpRequest): Promise<HilinkHttpResponse>;
+}
+export type HilinkReplayExchange = HilinkHttpRequest & {
+    readonly response: HilinkHttpResponse;
+};

package/dist/providers/huawei-hilink/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/index.d.ts

@@ -0,0 +1,8 @@
+export * from './contracts.js';
+export * from './huawei-hilink/index.js';
+export * from './matcher.js';
+export * from './modem-manager/index.js';
+export * from './network-manager/index.js';
+export * from './registry.js';
+export * from './ufi-himi/index.js';
+export * from './zte-goform/index.js';

package/dist/providers/index.js

@@ -0,0 +1,8 @@
+export * from './contracts.js';
+export * from './huawei-hilink/index.js';
+export * from './matcher.js';
+export * from './modem-manager/index.js';
+export * from './network-manager/index.js';
+export * from './registry.js';
+export * from './ufi-himi/index.js';
+export * from './zte-goform/index.js';

package/dist/providers/matcher.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderMatcher } from './contracts.js';
+import type { ProviderRegistry } from './registry.js';
+export declare function createProviderMatcher(registry: ProviderRegistry): ProviderMatcher;