@envarai/envarpay 0.1.0-alpha.3 → 0.2.0-alpha.1

package/dist/commerce/config.js

@@ -0,0 +1,164 @@
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import addFormatsImport from 'ajv-formats';
+import canonicalizeImport from 'canonicalize';
+import { CommerceError } from './types.js';
+const canonicalize = canonicalizeImport;
+const addFormats = addFormatsImport;
+const ajv = new Ajv2020({ allErrors: true, strict: true });
+addFormats(ajv);
+const schema = (name) => JSON.parse(readFileSync(new URL(`../../schemas/${name}`, import.meta.url), 'utf8'));
+const sellerValidator = ajv.compile(schema('envarpay.config.schema.json'));
+const buyerValidator = ajv.compile(schema('buyer-policy.schema.json'));
+const USDC = {
+    'eip155:84532': '0x036cbd53842c5426634e7929541ec2318f3dcf7e',
+    'eip155:8453': '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+};
+export function atomic(value) {
+    if (typeof value !== 'string' || !/^[1-9][0-9]{0,77}$/.test(value))
+        throw new CommerceError('invalid_amount', 'Use a positive integer string in smallest currency units');
+    const n = BigInt(value);
+    if (n >= 2n ** 256n)
+        throw new CommerceError('invalid_amount', 'Amount exceeds supported integer range');
+    return n;
+}
+function noExternalRefs(value) {
+    if (Array.isArray(value)) {
+        value.forEach(noExternalRefs);
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (['$ref', '$dynamicRef'].includes(key) && (typeof child !== 'string' || !child.startsWith('#')))
+            throw new CommerceError('external_schema_ref', 'Input schemas must contain only local references');
+        noExternalRefs(child);
+    }
+}
+export function validateUrl(value, allowPrivate = false) {
+    const url = new URL(value);
+    if (!['https:', ...(allowPrivate ? ['http:'] : [])].includes(url.protocol) || !url.hostname || url.username || url.password || url.hash)
+        throw new CommerceError('invalid_url', 'Use an HTTP(S) URL without embedded credentials or fragment');
+    return url;
+}
+export function currencyOf(profile) {
+    return profile.adapter === 'x402' ? `${profile.network}/erc20:${profile.asset.toLowerCase()}` : profile.currency;
+}
+function assertJson(value) {
+    if (typeof value === 'number' && (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))))
+        throw new CommerceError('unsafe_json_number', 'Use strings for integers outside the safe JSON number range');
+    if (value === undefined || typeof value === 'function' || typeof value === 'bigint' || typeof value === 'symbol')
+        throw new CommerceError('invalid_json', 'Value must be JSON');
+    if (value && typeof value === 'object') {
+        if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+            throw new CommerceError('invalid_json', 'Only plain JSON objects are supported');
+        for (const child of Object.values(value))
+            assertJson(child);
+    }
+}
+export function digest(value) {
+    assertJson(value);
+    const serialized = canonicalize(value);
+    if (serialized === undefined)
+        throw new CommerceError('invalid_json', 'Cannot canonicalize input');
+    return createHash('sha256').update(serialized).digest('hex');
+}
+export function loadCommerceConfig(value) {
+    if (!sellerValidator(value))
+        throw new CommerceError('invalid_config', ajv.errorsText(sellerValidator.errors));
+    const config = structuredClone(value);
+    const services = new Set();
+    for (const profile of Object.values(config.paymentProfiles)) {
+        if (profile.adapter === 'x402') {
+            if (USDC[profile.network] !== profile.asset.toLowerCase() || BigInt(profile.payTo) === 0n)
+                throw new CommerceError('unsupported_payment_profile', 'MVP accepts official Base or Base Sepolia USDC and a nonzero receiving address');
+            validateUrl(profile.facilitatorUrl);
+        }
+    }
+    for (const service of config.services) {
+        if (services.has(service.id))
+            throw new CommerceError('duplicate_service', 'Service IDs must be unique');
+        services.add(service.id);
+        validateUrl(service.execution.cardUrl, true);
+        noExternalRefs(service.contract.inputSchema);
+        const inputAjv = new Ajv2020({ strict: true });
+        addFormats(inputAjv);
+        inputAjv.compile(service.contract.inputSchema);
+        const offers = new Set();
+        for (const offer of service.offers) {
+            if (offers.has(offer.id))
+                throw new CommerceError('duplicate_offer', 'Offer IDs must be unique within a service');
+            offers.add(offer.id);
+            if (offer.pricing.kind === 'free')
+                continue;
+            const profile = config.paymentProfiles[offer.paymentProfile];
+            if (!profile)
+                throw new CommerceError('missing_payment_profile', 'Offer refers to an unknown payment profile');
+            let low, high;
+            if (offer.pricing.kind === 'fixed')
+                low = high = atomic(offer.pricing.amount);
+            else {
+                const q = offer.pricing.quantity;
+                if (q.min > q.max)
+                    throw new CommerceError('invalid_quantity', 'Quantity bounds are reversed');
+                let node = service.contract.inputSchema;
+                for (const part of q.pointer.slice(1).split('/')) {
+                    const key = part.replace(/~1/g, '/').replace(/~0/g, '~');
+                    const props = node.properties;
+                    node = props && Object.hasOwn(props, key) ? props[key] : {};
+                }
+                if (node.type !== 'array' || q.min < Number(node.minItems ?? 0) || q.max > Number(node.maxItems ?? 10000))
+                    throw new CommerceError('invalid_quantity', 'Quantity must reference a bounded declared array');
+                low = atomic(offer.pricing.unitAmount) * BigInt(q.min);
+                high = atomic(offer.pricing.unitAmount) * BigInt(q.max);
+            }
+            if (high >= 2n ** 256n)
+                throw new CommerceError('invalid_amount', 'Maximum total exceeds supported integer range');
+            if (profile.adapter === 'mpp' && low < 50n)
+                throw new CommerceError('card_minimum', 'USD card orders must be at least 50 cents');
+        }
+    }
+    return config;
+}
+export function loadBuyerPolicy(value) {
+    if (!buyerValidator(value))
+        throw new CommerceError('invalid_policy', ajv.errorsText(buyerValidator.errors));
+    const policy = structuredClone(value);
+    const normalizedCurrency = (currency) => {
+        if (currency === 'usd')
+            return currency;
+        const match = /^(eip155:[1-9][0-9]*)\/erc20:(0x[0-9a-fA-F]{40})$/.exec(currency);
+        if (!match || USDC[match[1]] !== match[2].toLowerCase())
+            throw new CommerceError('unsupported_currency', 'Buyer budget must use USD or an official supported USDC asset');
+        return `${match[1]}/erc20:${match[2].toLowerCase()}`;
+    };
+    const limits = new Map();
+    for (const b of policy.budgets) {
+        b.currency = normalizedCurrency(b.currency);
+        if (limits.has(b.currency))
+            throw new CommerceError('duplicate_budget', 'Only one budget per currency is allowed');
+        limits.set(b.currency, atomic(b.maxTotal));
+    }
+    const ids = new Set();
+    for (const peer of policy.peers) {
+        validateUrl(peer.cardUrl);
+        if (ids.has(peer.id))
+            throw new CommerceError('duplicate_peer', 'Peer IDs must be unique');
+        ids.add(peer.id);
+        if (peer.protocol === 'free')
+            continue;
+        peer.currency = normalizedCurrency(peer.currency);
+        if (peer.protocol === 'x402') {
+            if (!/^0x[0-9a-fA-F]{40}$/.test(peer.recipient) || BigInt(peer.recipient) === 0n || peer.currency === 'usd')
+                throw new CommerceError('invalid_recipient', 'x402 peers require a nonzero EVM recipient and USDC asset');
+            peer.recipient = peer.recipient.toLowerCase();
+        }
+        else if (peer.currency !== 'usd' || !/^profile_[A-Za-z0-9]+$/.test(peer.recipient))
+            throw new CommerceError('invalid_recipient', 'MPP peers require USD and a verified Stripe merchant profile');
+        const limit = limits.get(peer.currency);
+        if (limit === undefined || atomic(peer.maxPerPurchase) > limit)
+            throw new CommerceError('invalid_budget', 'Each peer needs a cumulative budget at least as large as its per-purchase limit');
+    }
+    return policy;
+}

package/dist/commerce/envar-runtime.d.ts

@@ -0,0 +1,46 @@
+import { type CommerceConfig, type Service } from "./types.js";
+import { CommerceServer, type ExecuteOrder } from "./server.js";
+import { EnvarIntegration, type EnvarCandidate } from "./envar.js";
+/** The credential and input encoding for an original revision stay fixed across updates/restarts. */
+export declare class PinnedUpstreams {
+    private readonly path;
+    private readonly credentials;
+    private readonly inputEncoding;
+    private readonly fetchImpl;
+    private readonly signal?;
+    private bindings;
+    private readonly executors;
+    readonly execute: ExecuteOrder;
+    constructor(path: string, credentials: Readonly<Record<string, string>>, inputEncoding?: Readonly<Record<string, "data" | "json-text">>, fetchImpl?: typeof fetch, signal?: AbortSignal | undefined);
+    prepare(config: CommerceConfig, history?: readonly Service[]): void;
+    private executor;
+}
+/** Merge a single published service without silently renaming/conflicting shared payment profiles. */
+export declare function mergeEnvarService(base: CommerceConfig, candidate: EnvarCandidate): CommerceConfig;
+/** Restore acknowledged local revisions before opening the listener, without a network request. */
+export declare function restoreEnvarConfig(base: CommerceConfig, integration: EnvarIntegration, history?: readonly {
+    service: Service;
+    profiles: CommerceConfig["paymentProfiles"];
+}[]): CommerceConfig;
+export interface EnvarSellerRuntimeOptions {
+    integration: EnvarIntegration;
+    server: CommerceServer;
+    upstreams: PinnedUpstreams;
+    pollIntervalMs?: number;
+    /** Local payment adapters/merchant credentials must already exist; config sync cannot create them. */
+    validateConfig?: (config: CommerceConfig) => void;
+    onError?: (code: string) => void;
+}
+export declare class EnvarSellerRuntime {
+    private readonly options;
+    private timer?;
+    private running?;
+    private stopped;
+    private failures;
+    private readonly interval;
+    constructor(options: EnvarSellerRuntimeOptions);
+    private apply;
+    syncOnce(): Promise<void>;
+    start(): void;
+    stop(): Promise<void>;
+}

package/dist/commerce/envar-runtime.js

@@ -0,0 +1,256 @@
+/** Seller runtime wiring for the optional directory connection; never used by independent purchase paths. */
+import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { digest, loadCommerceConfig } from "./config.js";
+import { CommerceError } from "./types.js";
+import { nativeA2AExecutor } from "./upstream.js";
+function privateJson(path) {
+    const stat = lstatSync(path);
+    if (!stat.isFile() ||
+        stat.isSymbolicLink() ||
+        (stat.mode & 0o077) !== 0 ||
+        stat.size > 1024 * 1024)
+        throw new CommerceError("upstream_binding_file", "Use a bounded owner-only upstream binding file");
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function writePrivate(path, value) {
+    const folder = dirname(path);
+    mkdirSync(folder, { recursive: true, mode: 0o700 });
+    const stat = lstatSync(folder);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0)
+        throw new CommerceError("upstream_binding_directory", "Use an owner-only runtime state directory");
+    if (existsSync(path))
+        privateJson(path);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, JSON.stringify(value), {
+            mode: 0o600,
+            flag: "wx",
+            flush: true,
+        });
+        renameSync(temporary, path);
+        const fd = openSync(folder, "r");
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    finally {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+}
+/** The credential and input encoding for an original revision stay fixed across updates/restarts. */
+export class PinnedUpstreams {
+    path;
+    credentials;
+    inputEncoding;
+    fetchImpl;
+    signal;
+    bindings = {};
+    executors = new Map();
+    execute;
+    constructor(path, credentials, inputEncoding = {}, fetchImpl = fetch, signal) {
+        this.path = path;
+        this.credentials = credentials;
+        this.inputEncoding = inputEncoding;
+        this.fetchImpl = fetchImpl;
+        this.signal = signal;
+        if (existsSync(path)) {
+            const value = privateJson(path);
+            if (value.version !== 1 ||
+                !value.bindings ||
+                typeof value.bindings !== "object" ||
+                Array.isArray(value.bindings))
+                throw new CommerceError("upstream_bindings", "Invalid private upstream binding state");
+            for (const [key, binding] of Object.entries(value.bindings))
+                if (!/^[a-z][a-z0-9-]{0,63}:[1-9][0-9]*$/.test(key) ||
+                    !binding ||
+                    typeof binding.cardUrl !== "string" ||
+                    typeof binding.token !== "string" ||
+                    binding.token.length < 16 ||
+                    !["data", "json-text"].includes(binding.inputEncoding))
+                    throw new CommerceError("upstream_bindings", "Invalid private upstream binding state");
+            this.bindings = value.bindings;
+        }
+        const self = this;
+        this.execute = async function* (order, service) {
+            yield* self.executor(service)(order, service);
+        };
+        this.execute.continue = async function* (order, service, continuation, remote) {
+            yield* self.executor(service).continue(order, service, continuation, remote);
+        };
+        this.execute.recover = (order, service, remote) => self.executor(service).recover(order, service, remote);
+        this.execute.remoteInterface = (task) => {
+            for (const executor of self.executors.values()) {
+                const value = executor.remoteInterface?.(task);
+                if (value)
+                    return value;
+            }
+            return undefined;
+        };
+    }
+    prepare(config, history = []) {
+        const next = structuredClone(this.bindings), current = new Set(config.services.map((s) => `${s.id}:${s.revision}`));
+        for (const service of [...history, ...config.services]) {
+            const key = `${service.id}:${service.revision}`, saved = next[key], explicit = this.credentials[key];
+            if (saved) {
+                if (saved.cardUrl !== service.execution.cardUrl ||
+                    (explicit !== undefined && explicit !== saved.token))
+                    throw new CommerceError("upstream_binding_changed", "Original runtime origin/credential differs from its private revision binding");
+                continue;
+            }
+            if (!current.has(key) && !explicit)
+                throw new CommerceError("historical_upstream_credentials", "Provide an explicit serviceId:revision credential for historical Tasks before first binding migration");
+            const token = explicit ?? this.credentials[service.id], encoding = this.inputEncoding[key] ?? this.inputEncoding[service.id] ?? "data";
+            if (!token ||
+                token.length < 16 ||
+                !["data", "json-text"].includes(encoding))
+                throw new CommerceError("upstream_credentials", "Provide local upstream credentials and explicit input encoding");
+            next[key] = {
+                cardUrl: service.execution.cardUrl,
+                token,
+                inputEncoding: encoding,
+            };
+        }
+        writePrivate(resolve(this.path), { version: 1, bindings: next });
+        this.bindings = next;
+    }
+    executor(service) {
+        const key = `${service.id}:${service.revision}`, binding = this.bindings[key];
+        if (!binding || binding.cardUrl !== service.execution.cardUrl)
+            throw new CommerceError("upstream_binding_missing", "Original runtime credential binding is unavailable");
+        let executor = this.executors.get(key);
+        if (!executor) {
+            executor = nativeA2AExecutor({ [key]: binding.token }, this.fetchImpl, this.signal, { inputEncoding: { [service.id]: binding.inputEncoding } });
+            this.executors.set(key, executor);
+        }
+        return executor;
+    }
+}
+/** Merge a single published service without silently renaming/conflicting shared payment profiles. */
+export function mergeEnvarService(base, candidate) {
+    const incoming = loadCommerceConfig(candidate.config), service = incoming.services[0];
+    if (incoming.agent.id !== base.agent.id || incoming.services.length !== 1)
+        throw new CommerceError("envar_runtime_agent", "Candidate does not match this runtime");
+    const prior = base.services.find((s) => s.id === service.id);
+    if (prior && service.revision < prior.revision)
+        throw new CommerceError("envar_stale_revision", "An older candidate cannot replace the active service");
+    const retained = base.services.filter((s) => s.id !== service.id), references = new Set(retained.flatMap((s) => s.offers.map((o) => o.paymentProfile).filter((p) => !!p)));
+    for (const [key, profile] of Object.entries(incoming.paymentProfiles))
+        if (references.has(key) &&
+            digest(profile) !== digest(base.paymentProfiles[key]))
+            throw new CommerceError("envar_profile_conflict", "Use a unique payment profile ID when its receiving identity differs from another active service");
+    const profiles = { ...base.paymentProfiles, ...incoming.paymentProfiles }, services = [...retained, service], used = new Set(services.flatMap((s) => s.offers.map((o) => o.paymentProfile).filter((p) => !!p)));
+    return loadCommerceConfig({
+        ...base,
+        paymentProfiles: Object.fromEntries(Object.entries(profiles).filter(([key]) => used.has(key))),
+        services,
+    });
+}
+/** Restore acknowledged local revisions before opening the listener, without a network request. */
+export function restoreEnvarConfig(base, integration, history = []) {
+    const registered = history.map((snapshot) => ({
+        id: snapshot.service.id,
+        revision: snapshot.service.revision,
+        digest: digest(snapshot),
+    }));
+    let result = base;
+    for (const candidate of [
+        ...integration.appliedCandidates(),
+        ...integration.pendingCandidates(registered),
+    ].sort((a, b) => a.revision - b.revision)) {
+        const current = result.services.find((s) => s.id === candidate.config.services[0].id);
+        if (current && current.revision > candidate.revision)
+            continue;
+        result = mergeEnvarService(result, candidate);
+    }
+    return result;
+}
+export class EnvarSellerRuntime {
+    options;
+    timer;
+    running;
+    stopped = false;
+    failures = 0;
+    interval;
+    constructor(options) {
+        this.options = options;
+        this.interval = options.pollIntervalMs ?? 10000;
+        if (!Number.isInteger(this.interval) ||
+            this.interval < 1000 ||
+            this.interval > 300000)
+            throw new CommerceError("envar_poll_interval", "Poll interval must be between one second and five minutes");
+    }
+    async apply(candidate) {
+        const config = mergeEnvarService(this.options.server.config, candidate);
+        this.options.validateConfig?.(config);
+        this.options.upstreams.prepare(config, this.options.server.store.catalogHistory().map((entry) => entry.service));
+        this.options.server.applyConfig(config);
+        const expected = candidate.config.services[0], actual = this.options.server.config.services.find((s) => s.id === expected.id);
+        const stored = this.options.server.store
+            .catalogHistory()
+            .find((entry) => entry.service.id === expected.id &&
+            entry.service.revision === expected.revision);
+        if (!actual || !stored || digest(actual) !== digest(expected))
+            throw new CommerceError("envar_application_proof", "Active runtime and persisted service do not match the candidate");
+        return {
+            digest: candidate.digest,
+            services: [
+                { id: actual.id, revision: actual.revision, digest: digest(stored) },
+            ],
+        };
+    }
+    syncOnce() {
+        if (this.stopped)
+            return Promise.resolve();
+        if (this.running)
+            return this.running;
+        this.running = (async () => {
+            try {
+                for (const candidate of await this.options.integration.pullCandidates())
+                    await this.options.integration.applyCandidate(candidate, (c) => this.apply(c));
+            }
+            finally {
+                await this.options.integration.flush({ limit: 1 });
+            }
+        })().finally(() => {
+            this.running = undefined;
+        });
+        return this.running;
+    }
+    start() {
+        if (this.timer || this.running || this.stopped)
+            return;
+        const tick = async () => {
+            try {
+                await this.syncOnce();
+                this.failures = 0;
+            }
+            catch (error) {
+                this.failures++;
+                this.options.onError?.(error instanceof CommerceError ? error.code : "envar_sync_failed");
+            }
+            finally {
+                if (!this.stopped) {
+                    this.timer = setTimeout(() => {
+                        this.timer = undefined;
+                        void tick();
+                    }, Math.min(300000, this.interval * 2 ** Math.min(this.failures, 5)));
+                    this.timer.unref();
+                }
+            }
+        };
+        void tick();
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.running?.catch(() => undefined);
+    }
+}

package/dist/commerce/envar.d.ts

@@ -0,0 +1,126 @@
+import { type CommerceConfig, type PriceQuote } from "./types.js";
+declare const STATUS_KINDS: readonly ["seller_started", "seller_completed", "seller_failed", "buyer_received", "buyer_failed", "execution_unknown"];
+export type EnvarStatusKind = (typeof STATUS_KINDS)[number];
+export interface EnvarPolicy {
+    enabled: true;
+    platformOrigin: string;
+    agentId: string;
+    runtimeAgentId: string;
+    acceptUpdates: boolean;
+    allowedServices: string[];
+    allowedUpstreamOrigins: string[];
+    allowedX402: {
+        network: string;
+        asset: string;
+        payTo: string;
+        facilitatorOrigin: string;
+    }[];
+    allowedMppAccounts: string[];
+}
+export interface EnvarCandidate {
+    id: string;
+    service_id: string;
+    revision: number;
+    digest: string;
+    config: CommerceConfig;
+    publication: {
+        state: string;
+        desired_digest: string;
+    };
+}
+export interface EnvarApplicationProof {
+    digest: string;
+    services: {
+        id: string;
+        revision: number;
+        digest: string;
+    }[];
+}
+export interface EnvarIntegrationOptions {
+    policy: EnvarPolicy;
+    stateDirectory: string;
+    configDirectory: string;
+    /** Dedicated Agent-scoped credential, read locally; never persisted here. */
+    token: () => string | Promise<string>;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    responseLimitBytes?: number;
+    now?: () => number;
+}
+export interface EnvarX402Evidence {
+    network: string;
+    asset: string;
+    payer: string;
+    recipient: string;
+    amount: string;
+    nonce: string;
+    transaction: string;
+}
+export interface EnvarMppEvidence {
+    reference: string;
+    amount: string;
+    currency: string;
+}
+/** Same frozen fingerprint as CommerceStore.registerCatalog; callers must read actual persisted state. */
+export declare function envarServiceProofs(config: CommerceConfig): EnvarApplicationProof["services"];
+export declare class EnvarIntegration {
+    private readonly options;
+    readonly sourceInstance: string;
+    private readonly policy;
+    private readonly db;
+    private readonly lock;
+    private readonly configDirectory;
+    private readonly fetcher;
+    private readonly now;
+    private readonly timeoutMs;
+    private readonly limitBytes;
+    private flushing;
+    private applying;
+    private closed;
+    constructor(options: EnvarIntegrationOptions);
+    close(): void;
+    private open;
+    private request;
+    private candidate;
+    /** Latest locally acknowledged revisions; startup recovery never requires platform connectivity. */
+    appliedCandidates(): EnvarCandidate[];
+    /** Recover only pending applications already proven by the runtime's durable service catalog. */
+    pendingCandidates(registered: EnvarApplicationProof["services"]): EnvarCandidate[];
+    pullCandidates(): Promise<EnvarCandidate[]>;
+    applyCandidate(raw: EnvarCandidate, apply: (candidate: EnvarCandidate) => Promise<EnvarApplicationProof>): Promise<{
+        ackEventId: string;
+        configPath: string;
+    }>;
+    private enqueueAck;
+    private enqueue;
+    enqueueStatus(dedupeKey: string, report: {
+        orderId: string;
+        kind: EnvarStatusKind;
+    }): string;
+    enqueueX402Payment(dedupeKey: string, report: {
+        orderId: string;
+        quote: PriceQuote;
+        payment: EnvarX402Evidence;
+    }): string;
+    enqueueMppPayment(dedupeKey: string, report: {
+        orderId: string;
+        quote: PriceQuote;
+        payment: EnvarMppEvidence;
+    }): string;
+    queueStatus(): {
+        pending: number;
+        sent: number;
+        errors: {
+            eventId: string;
+            code: string;
+            attempts: number;
+        }[];
+    };
+    flush(options?: {
+        limit?: number;
+    }): Promise<{
+        sent: number;
+        pending: number;
+    }>;
+}
+export {};