@ceralive/modem-control 1.0.0 → 1.2.0

package/dist/observations/sources/router-shared.js

@@ -0,0 +1,68 @@
+// The claims every router admin API makes identically, in one place.
+//
+// HiLink, goform and HIMI are three vendor HTTP surfaces over a modem, and they share
+// a capability boundary: none of them exposes ModemManager's modem state, its 3GPP
+// registration enum, its lock enum or its SIM-type enum. Those read `unsupported`,
+// which is a durable claim about the SOURCE rather than about one poll — and stating
+// it once here is what stops the three normalizers from drifting into three different
+// answers for the same structural fact.
+//
+// SIM PRESENCE is deliberately NOT claimed. Each vendor reports a presence code of
+// its own (`SimStatus`, `simcard_state`, `simstate`) with vendor semantics, and no
+// migrated decoder covers them; guessing one would be exactly the invented reading
+// this layer exists to prevent. It reads `not-reported` and the vendor code stays
+// verbatim in the diagnostics block for the per-vendor providers to claim later.
+import { isUninformativeIdentity, modemHardwareLabel, modemHardwareName, } from '../../domain/index.js';
+import { knownMetric, unknownMetric } from '../metric.js';
+export function unsupportedRadioMetric(provenance) {
+    return unknownMetric('unsupported', provenance([]));
+}
+/**
+ * The SIM block every router source produces.
+ *
+ * `vendorPresenceField` NAMES the vendor's own presence code when the payload carried
+ * one, so the evidence records that a code exists and was deliberately not decoded —
+ * distinct from `no-evidence`, which says the payload offered nothing at all. Neither
+ * one is ever `absent`: claiming absence from a vendor code whose semantics no
+ * migrated decoder covers is precisely the invented reading this layer refuses.
+ */
+export function routerSim(provenance, vendorPresenceField) {
+    // The vendor field is NAMED in the evidence but is NOT consumed: no metric claims its
+    // value, so it must stay in the diagnostics block's `unmapped` set, verbatim, for the
+    // per-vendor provider that will one day decode it with evidence.
+    return {
+        presence: unknownMetric('not-reported', provenance([])),
+        presenceEvidence: vendorPresenceField === undefined
+            ? { kind: 'no-evidence', inspected: [] }
+            : { kind: 'vendor-code-unclaimed', field: vendorPresenceField },
+        lockRequired: unknownMetric('unsupported', provenance([])),
+        kind: unknownMetric('unsupported', provenance([])),
+        esimStatus: unknownMetric('unsupported', provenance([])),
+    };
+}
+/** Router admin APIs report no measurement-recency flag; that is a source capability claim. */
+export function unsupportedQualityRecent(provenance) {
+    return unknownMetric('unsupported', provenance([]));
+}
+/**
+ * A router's product name, screened by the migrated presentation rules.
+ *
+ * `modemHardwareLabel` falls back to a generic label when its input says nothing, and
+ * publishing that as a KNOWN value would be reporting a name no device gave. So an
+ * uninformative product string is refused up front and reads `not-reported` instead.
+ */
+export function routerHardware(provenance, product) {
+    if (product === undefined || isUninformativeIdentity(product.name)) {
+        const source = provenance(product === undefined ? [] : [product.field]);
+        return {
+            label: unknownMetric('not-reported', source),
+            displayName: unknownMetric('not-reported', source),
+        };
+    }
+    const source = provenance([product.field]);
+    const identity = { model: product.name };
+    return {
+        label: knownMetric(modemHardwareLabel(identity), source),
+        displayName: knownMetric(modemHardwareName(identity), source),
+    };
+}

package/dist/observations/sources/ufi.d.ts

@@ -0,0 +1,10 @@
+import type { ObservationEnvelope } from '../../domain/index.js';
+import { type NormalizationContext } from '../envelope.js';
+import type { NormalizedModemObservation } from '../model.js';
+export type UfiObservationInput = {
+    readonly sysinfo: string;
+    readonly overview: string;
+    readonly status: string;
+    readonly produceInfo?: string;
+};
+export declare function normalizeUfiObservation(input: UfiObservationInput, context: NormalizationContext): ObservationEnvelope<NormalizedModemObservation>;

package/dist/observations/sources/ufi.js

@@ -0,0 +1,111 @@
+// Qualcomm UFI / HIMI → normalized observation.
+//
+// UFI answers three endpoints per read, each an envelope of its own (`{reply, params}`),
+// and the migrated `parseUfiSignal` already folds them in the vendor's own precedence
+// order. This module keeps all three bodies verbatim — including the `reply` field,
+// which is how a `SessionOut` refusal is told apart from a body that simply lacked the
+// key — and reports the ONE signal reading the source actually provides.
+//
+// Its overview endpoint returns an IMSI and an ICCID. They are retained, because
+// normalization does not get to decide what a diagnostician may need, and they are
+// masked by the shared key-based redactor on the way to anything that renders. That
+// split — retain here, redact at the boundary — is why `raw` is documented as a
+// redaction-class surface rather than as safe-by-default data.
+import { parseUfiDetails, parseUfiSignal } from '../../hardware/router-parsers.js';
+import { freshObservation, metricProvenance } from '../envelope.js';
+import { metricFromRouterSignal, unknownMetric } from '../metric.js';
+import { createObservationDiagnostics, } from '../provenance.js';
+import { hasRawField, mergeRawRecords, normalizeRawValue, parseJsonObject, prefixRawRecord, rawKey, } from '../raw.js';
+import { routerHardware, routerSim, unsupportedQualityRecent, unsupportedRadioMetric, } from './router-shared.js';
+const SOURCE = 'ufi-himiapi';
+const SYSINFO = 'sysinfo';
+const OVERVIEW = 'overview';
+const STATUS = 'status';
+const PRODUCE_INFO = 'produce-info';
+const SESSION_REFUSAL = 'SessionOut';
+/** HIMI's own SIM presence code. Named as evidence, never decoded into a presence. */
+const SIM_STATE = rawKey(SYSINFO, 'simstate');
+export function normalizeUfiObservation(input, context) {
+    const bodies = [
+        [SYSINFO, input.sysinfo],
+        [OVERVIEW, input.overview],
+        [STATUS, input.status],
+        [PRODUCE_INFO, input.produceInfo ?? ''],
+    ];
+    const notes = [];
+    const records = bodies.map(([name, text]) => {
+        const parsed = parseJsonObject(text);
+        if (parsed === undefined && text.trim() !== '') {
+            notes.push({ code: 'unparseable-body', field: name });
+        }
+        if (parsed?.reply === SESSION_REFUSAL) {
+            notes.push({ code: 'auth-expired', field: rawKey(name, 'reply') });
+        }
+        return prefixRawRecord(name, flattenUfiEnvelope(parsed));
+    });
+    const raw = mergeRawRecords(...records);
+    const consumed = [];
+    const provenance = (fields, authority) => {
+        consumed.push(...fields);
+        return authority === undefined
+            ? metricProvenance(SOURCE, context, fields)
+            : metricProvenance(SOURCE, context, fields, authority);
+    };
+    const signalModel = parseUfiSignal({
+        sysinfo: input.sysinfo,
+        overview: input.overview,
+        status: input.status,
+    });
+    const details = parseUfiDetails({
+        overview: input.overview,
+        sysinfo: input.sysinfo,
+        ...(input.produceInfo === undefined ? {} : { produceInfo: input.produceInfo }),
+    });
+    const product = details?.product;
+    return freshObservation(SOURCE, context, {
+        source: SOURCE,
+        hardware: routerHardware(provenance, product === undefined
+            ? undefined
+            : { name: product, field: rawKey(PRODUCE_INFO, 'productname') }),
+        radio: {
+            modemState: unsupportedRadioMetric(provenance),
+            registration: unsupportedRadioMetric(provenance),
+            accessTechnologies: unknownMetric('unsupported', provenance([])),
+            modeLabel: unknownMetric('not-reported', provenance([])),
+        },
+        signal: {
+            quality: unknownMetric('unsupported', provenance([])),
+            qualityRecent: unsupportedQualityRecent(provenance),
+            bars: metricFromRouterSignal(signalModel.bars, provenance([])),
+            maxBars: metricFromRouterSignal(signalModel.max_bars, provenance([])),
+            dbm: metricFromRouterSignal(signalModel.dbm, provenance([
+                rawKey(SYSINFO, 'SIGNAL'),
+                rawKey(OVERVIEW, 'SIGNAL'),
+                rawKey(STATUS, 'signalStrength'),
+            ])),
+            rsrp: metricFromRouterSignal(signalModel.rsrp, provenance([])),
+            rsrq: metricFromRouterSignal(signalModel.rsrq, provenance([])),
+            snr: metricFromRouterSignal(signalModel.snr, provenance([])),
+            sinr: metricFromRouterSignal(signalModel.sinr, provenance([])),
+        },
+        sim: routerSim(provenance, hasRawField(raw, SIM_STATE) ? SIM_STATE : undefined),
+        diagnostics: createObservationDiagnostics({ source: SOURCE, raw, consumed, notes }),
+    });
+}
+/** `{reply, params}` flattened to one level — `params` members keep their own names. */
+function flattenUfiEnvelope(parsed) {
+    const out = {};
+    if (parsed === undefined) {
+        return out;
+    }
+    for (const [key, value] of Object.entries(parsed)) {
+        if (key === 'params' && typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            for (const [field, param] of Object.entries(value)) {
+                out[field] = normalizeRawValue(param);
+            }
+            continue;
+        }
+        out[key] = normalizeRawValue(value);
+    }
+    return out;
+}

package/dist/observations/sources/zte.d.ts

@@ -0,0 +1,7 @@
+import type { ObservationEnvelope } from '../../domain/index.js';
+import { type NormalizationContext } from '../envelope.js';
+import type { NormalizedModemObservation } from '../model.js';
+export type ZteObservationInput = {
+    readonly body: string;
+};
+export declare function normalizeZteObservation(input: ZteObservationInput, context: NormalizationContext): ObservationEnvelope<NormalizedModemObservation>;

package/dist/observations/sources/zte.js

@@ -0,0 +1,71 @@
+// ZTE goform → normalized observation.
+//
+// One goform response answers many keys at once, so the migrated `parseZteSignal` and
+// `parseZteDetails` are both driven from the SAME body here — and everything neither
+// of them claims (`wan_lte_ca`, `rmcc`, `lte_pci`, the cell id, the roaming flag) is
+// retained verbatim in the diagnostics block. That retention is the point: a
+// carrier-aggregation flag no normalized field has a slot for is still the difference
+// between a diagnosable report and a shrug.
+//
+// A body that will not parse is an OBSERVATION whose metrics are `malformed`, not an
+// unavailable one. The bytes arrived; what failed was decoding them, and an
+// unavailable envelope would have to discard them to say so.
+import { parseZteDetails, parseZteSignal } from '../../hardware/router-parsers.js';
+import { freshObservation, metricProvenance } from '../envelope.js';
+import { knownMetric, metricFromRouterSignal, unknownMetric, } from '../metric.js';
+import { createObservationDiagnostics } from '../provenance.js';
+import { hasRawField, parseJsonRecord, prefixRawRecord, rawKey } from '../raw.js';
+import { routerHardware, routerSim, unsupportedQualityRecent, unsupportedRadioMetric, } from './router-shared.js';
+const SOURCE = 'zte-goform';
+const BODY = 'goform';
+/** ZTE's own SIM presence code. Named as evidence, never decoded into a presence. */
+const SIM_CARD_STATE = rawKey(BODY, 'simcard_state');
+export function normalizeZteObservation(input, context) {
+    const parsed = parseJsonRecord(input.body);
+    const raw = prefixRawRecord(BODY, parsed);
+    const notes = [];
+    if (parsed === undefined) {
+        notes.push({ code: input.body.trim() === '' ? 'empty-body' : 'unparseable-body', field: BODY });
+    }
+    const consumed = [];
+    const provenance = (fields, authority) => {
+        consumed.push(...fields);
+        return authority === undefined
+            ? metricProvenance(SOURCE, context, fields)
+            : metricProvenance(SOURCE, context, fields, authority);
+    };
+    const signalModel = parseZteSignal(input.body);
+    const details = parseZteDetails(input.body);
+    return freshObservation(SOURCE, context, {
+        source: SOURCE,
+        hardware: routerHardware(provenance, undefined),
+        radio: {
+            modemState: unsupportedRadioMetric(provenance),
+            registration: unsupportedRadioMetric(provenance),
+            accessTechnologies: unknownMetric('unsupported', provenance([])),
+            modeLabel: normalizeModeLabel(details?.network_type, parsed !== undefined, provenance),
+        },
+        signal: {
+            quality: unknownMetric('unsupported', provenance([])),
+            qualityRecent: unsupportedQualityRecent(provenance),
+            bars: metricFromRouterSignal(signalModel.bars, provenance([rawKey(BODY, 'signalbar')], 'derived')),
+            // The goform payload carries no maximum; the migrated parser states the
+            // vendor's fixed five-bar scale, which is a derivation and says so.
+            maxBars: metricFromRouterSignal(signalModel.max_bars, provenance([], 'derived')),
+            dbm: metricFromRouterSignal(signalModel.dbm, provenance([rawKey(BODY, 'rssi')])),
+            rsrp: metricFromRouterSignal(signalModel.rsrp, provenance([rawKey(BODY, 'lte_rsrp')])),
+            rsrq: metricFromRouterSignal(signalModel.rsrq, provenance([rawKey(BODY, 'lte_rsrq')])),
+            snr: metricFromRouterSignal(signalModel.snr, provenance([rawKey(BODY, 'lte_snr')])),
+            sinr: metricFromRouterSignal(signalModel.sinr, provenance([])),
+        },
+        sim: routerSim(provenance, hasRawField(raw, SIM_CARD_STATE) ? SIM_CARD_STATE : undefined),
+        diagnostics: createObservationDiagnostics({ source: SOURCE, raw, consumed, notes }),
+    });
+}
+function normalizeModeLabel(networkType, parsed, provenance) {
+    const source = provenance([rawKey(BODY, 'network_type')]);
+    if (networkType !== undefined) {
+        return knownMetric(networkType, source);
+    }
+    return unknownMetric(parsed ? 'not-reported' : 'malformed', source);
+}

package/dist/observations/state-separation.d.ts

@@ -0,0 +1,64 @@
+import type { DeviceGeneration, EpochMillis, ObservationEnvelope } from '../domain/index.js';
+/** What an operator asked for. Not a claim that anything acted on it. */
+export type DesiredProfile<T> = {
+    readonly kind: 'desired';
+    readonly profile: T;
+    readonly requestedAt: EpochMillis;
+    /** Opaque origin label (an RPC caller, a policy engine). Never a credential. */
+    readonly requestedBy: string;
+};
+/** What was actually put into force, and by which operation, in which generation. */
+export type AppliedConfiguration<T> = {
+    readonly kind: 'applied';
+    readonly configuration: T;
+    readonly appliedAt: EpochMillis;
+    readonly generation: DeviceGeneration;
+    readonly operationId: string;
+};
+/** What the device itself reports — always through an envelope, never bare. */
+export type ObservedState<T> = {
+    readonly kind: 'observed';
+    readonly observation: ObservationEnvelope<T>;
+};
+export declare function desiredProfile<T>(profile: T, requestedAt: EpochMillis, requestedBy: string): DesiredProfile<T>;
+export declare function appliedConfiguration<T>(input: {
+    readonly configuration: T;
+    readonly appliedAt: EpochMillis;
+    readonly generation: DeviceGeneration;
+    readonly operationId: string;
+}): AppliedConfiguration<T>;
+export declare function observedState<T>(observation: ObservationEnvelope<T>): ObservedState<T>;
+/**
+ * The three-slot view. There is deliberately no fourth field holding a merged
+ * "effective" value: an effective value is a RENDERING decision, and computing one
+ * here would bake a policy every consumer would then have to work around.
+ */
+export type ModemStateView<TDesired, TApplied, TObserved> = {
+    readonly desired: DesiredProfile<TDesired> | null;
+    readonly applied: AppliedConfiguration<TApplied> | null;
+    readonly observed: ObservedState<TObserved>;
+};
+export declare const STATE_VIEW_SLOTS: readonly ['desired', 'applied', 'observed'];
+export type StateViewSlot = (typeof STATE_VIEW_SLOTS)[number];
+export type SlotComparison = {
+    readonly status: 'aligned';
+} | {
+    readonly status: 'diverged';
+}
+/** One side has nothing to compare — NOT the same as agreeing. */
+ | {
+    readonly status: 'indeterminate';
+    readonly missing: StateViewSlot;
+};
+/**
+ * Two independent comparisons, never one verdict.
+ *
+ * `desiredVsApplied` answers "did our write happen"; `appliedVsObserved` answers "did
+ * it stick". A single boolean cannot distinguish a request that was never carried out
+ * from one the network undid a second later, and those need opposite responses.
+ */
+export type StateDivergence = {
+    readonly desiredVsApplied: SlotComparison;
+    readonly appliedVsObserved: SlotComparison;
+};
+export declare function describeStateDivergence<T>(view: ModemStateView<T, T, T>, equals: (left: T, right: T) => boolean): StateDivergence;

package/dist/observations/state-separation.js

@@ -0,0 +1,52 @@
+// Desired, applied and observed are THREE things, and this module refuses to make
+// them one.
+//
+// The pattern is NetworkManager's: a connection PROFILE is what an operator asked
+// for, an active connection's BEARER is what was actually put into force, and the
+// device's own reported state is what the hardware is currently doing. All three are
+// routinely different at once — a profile edited but not re-activated, a bearer that
+// survived a profile change, a device that dropped registration without anything
+// having been re-applied — and a merged "current state" blob has to pick one of them
+// and silently lose the other two.
+//
+// Concretely, collapsing them makes these questions unanswerable:
+//   · did the operator's last change actually take effect, or is it only pending?
+//   · is what the device reports the consequence of our write, or of the network?
+//   · when a rollback is needed, what exactly do we roll back TO?
+//
+// So the three live in separate slots with separate `kind` discriminants, and the
+// comparison below reports TWO independent divergences instead of one verdict.
+// `NetworkManagerAdapter` (a later change) consumes exactly this shape.
+import { viewEnvelope } from './envelope.js';
+export function desiredProfile(profile, requestedAt, requestedBy) {
+    return { kind: 'desired', profile, requestedAt, requestedBy };
+}
+export function appliedConfiguration(input) {
+    return { kind: 'applied', ...input };
+}
+export function observedState(observation) {
+    return { kind: 'observed', observation };
+}
+export const STATE_VIEW_SLOTS = ['desired', 'applied', 'observed'];
+export function describeStateDivergence(view, equals) {
+    return {
+        desiredVsApplied: compareSlots(view.desired === null ? undefined : view.desired.profile, view.applied === null ? undefined : view.applied.configuration, view.desired === null ? 'desired' : 'applied', equals),
+        appliedVsObserved: compareSlots(view.applied === null ? undefined : view.applied.configuration, observedValue(view.observed), view.applied === null ? 'applied' : 'observed', equals),
+    };
+}
+/**
+ * The observed value, or `undefined` when the observation carries none.
+ *
+ * An unavailable observation is `indeterminate` against anything, never `aligned`:
+ * "we could not read it" is not evidence that it matches.
+ */
+function observedValue(observed) {
+    const view = viewEnvelope(observed.observation);
+    return view.kind === 'unavailable' ? undefined : view.value;
+}
+function compareSlots(left, right, missing, equals) {
+    if (left === undefined || right === undefined) {
+        return { status: 'indeterminate', missing };
+    }
+    return equals(left, right) ? { status: 'aligned' } : { status: 'diverged' };
+}

package/dist/operation-ids.d.ts

@@ -0,0 +1,2 @@
+export declare const MODEM_OPERATION_IDS: readonly ["modemmanager.radio-modes", "modemmanager.mode-combination", "modemmanager.bands", "modemmanager.signal", "modemmanager.sim", "modemmanager.power", "modemmanager.usb-composition", "status", "signal", "mode", "data", "ufi.signal.read", "ufi.details.read", "nv.write", "efs.write", "identity.write", "calibration.write", "firmware.flash", "edl.automation", "driver.blind-retry", "interface.blind-retry", "diag.write", "diag.info-probe", "shell.transport-fallback"];
+export type ModemOperationId = (typeof MODEM_OPERATION_IDS)[number];

package/dist/operation-ids.js

@@ -0,0 +1,26 @@
+export const MODEM_OPERATION_IDS = Object.freeze([
+    'modemmanager.radio-modes',
+    'modemmanager.mode-combination',
+    'modemmanager.bands',
+    'modemmanager.signal',
+    'modemmanager.sim',
+    'modemmanager.power',
+    'modemmanager.usb-composition',
+    'status',
+    'signal',
+    'mode',
+    'data',
+    'ufi.signal.read',
+    'ufi.details.read',
+    'nv.write',
+    'efs.write',
+    'identity.write',
+    'calibration.write',
+    'firmware.flash',
+    'edl.automation',
+    'driver.blind-retry',
+    'interface.blind-retry',
+    'diag.write',
+    'diag.info-probe',
+    'shell.transport-fallback',
+]);

package/dist/operations/contracts.d.ts

@@ -0,0 +1,72 @@
+import type { DeviceGeneration, OperationCompletion, OperationDescriptor, OperationResult, PhysicalModemId } from '../domain/index.js';
+export type OperationPreconditionRequest = {
+    readonly operationId: string;
+    readonly physicalModemId: PhysicalModemId;
+    readonly generation: DeviceGeneration;
+    readonly descriptorId: string;
+    readonly preconditions: readonly string[];
+};
+export type OperationPreconditionResult = {
+    readonly status: 'satisfied';
+} | {
+    readonly status: 'refused';
+    readonly reason: string;
+};
+/** Live operation facts. Implementations must inspect them for every invocation. */
+export interface OperationPreconditionPort {
+    check(request: OperationPreconditionRequest): Promise<OperationPreconditionResult>;
+}
+export type OperationAttemptContext = {
+    readonly operationId: string;
+    readonly generation: DeviceGeneration;
+    readonly attempt: number;
+};
+export type OperationJournalEvent<I, O> = {
+    readonly phase: 'started';
+    readonly operationId: string;
+    readonly physicalModemId: PhysicalModemId;
+    readonly generation: DeviceGeneration;
+    readonly descriptor: OperationDescriptor<I, O>;
+    readonly input: I;
+} | {
+    readonly phase: 'completed';
+    readonly operationId: string;
+    readonly physicalModemId: PhysicalModemId;
+    readonly generation: DeviceGeneration;
+    readonly descriptor: OperationDescriptor<I, O>;
+    readonly result: OperationResult<O>;
+};
+export interface OperationJournalHook<I, O> {
+    record(event: OperationJournalEvent<I, O>): Promise<void>;
+}
+export type OperationExecution<I, O> = {
+    readonly operationId: string;
+    readonly physicalModemId: PhysicalModemId;
+    readonly descriptor: OperationDescriptor<I, O>;
+    readonly input: I;
+    readonly execute: (context: OperationAttemptContext) => Promise<OperationCompletion<O>>;
+    readonly readback?: (context: OperationAttemptContext) => Promise<OperationCompletion<O>>;
+    readonly rollback?: (context: OperationAttemptContext) => Promise<OperationCompletion<void>>;
+    readonly journal?: OperationJournalHook<I, O>;
+};
+export type ReconciliationExecution = {
+    readonly physicalModemId: PhysicalModemId;
+    readonly generation: DeviceGeneration;
+    readonly run: () => Promise<{
+        readonly status: 'reconciled';
+    } | {
+        readonly status: 'failed';
+        readonly reason: string;
+    }>;
+};
+export type ReconciliationResult = {
+    readonly status: 'reconciled';
+    readonly generation: DeviceGeneration;
+} | {
+    readonly status: 'not-required';
+    readonly generation: DeviceGeneration;
+} | {
+    readonly status: 'failed';
+    readonly reason: 'stale-generation' | string;
+    readonly generation: DeviceGeneration;
+};

package/dist/operations/contracts.js

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

package/dist/operations/index.d.ts

@@ -0,0 +1 @@
+export * from './operation-engine.js';

package/dist/operations/index.js

@@ -0,0 +1 @@
+export * from './operation-engine.js';

package/dist/operations/operation-engine.d.ts

@@ -0,0 +1,16 @@
+import { type DeviceGeneration, type OperationResult, type PhysicalModemId } from '../domain/index.js';
+import type { ModemControlCompositionRoot } from '../safety/index.js';
+import type { OperationExecution, OperationPreconditionPort, ReconciliationExecution, ReconciliationResult } from './contracts.js';
+export * from './contracts.js';
+export type OperationEngineOptions = {
+    readonly root: ModemControlCompositionRoot;
+    readonly currentGeneration: (physicalModemId: PhysicalModemId) => DeviceGeneration;
+    readonly preconditions: OperationPreconditionPort;
+};
+export declare class OperationEngine {
+    #private;
+    constructor(options: OperationEngineOptions);
+    invoke<I, O>(execution: OperationExecution<I, O>): Promise<OperationResult<O>>;
+    reconcile(execution: ReconciliationExecution): Promise<ReconciliationResult>;
+}
+export declare function createOperationEngine(options: OperationEngineOptions): OperationEngine;