@mercuryo-ai/magicpay-cli 0.1.0

package/dist/mock-secret-cabinet.js

@@ -0,0 +1,321 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { getMagicPayMockSecretRequestsPath } from '@mercuryo-ai/magicpay-home';
+import { resolveCatalogHost } from '@mercuryo-ai/magicpay-sdk/core';
+const MOCK_SECRET_REQUEST_STORE_PATH_ENV = 'MAGICPAY_MOCK_SECRET_REQUEST_STORE_PATH';
+const DEFAULT_MOCK_SECRET_REQUEST_STORE_PATH = getMagicPayMockSecretRequestsPath();
+let testMockSecretRequestStorePath;
+function resolveConfiguredStorePath() {
+    if (testMockSecretRequestStorePath) {
+        return testMockSecretRequestStorePath;
+    }
+    const configured = process.env[MOCK_SECRET_REQUEST_STORE_PATH_ENV]?.trim();
+    if (configured) {
+        return resolve(configured);
+    }
+    if (existsSync(DEFAULT_MOCK_SECRET_REQUEST_STORE_PATH)) {
+        return DEFAULT_MOCK_SECRET_REQUEST_STORE_PATH;
+    }
+    return DEFAULT_MOCK_SECRET_REQUEST_STORE_PATH;
+}
+function ensureMockCabinetDir() {
+    const storePath = resolveConfiguredStorePath();
+    mkdirSync(dirname(storePath), { recursive: true });
+    return storePath;
+}
+function readMockStore() {
+    const storePath = resolveConfiguredStorePath();
+    if (!existsSync(storePath)) {
+        return {
+            version: 2,
+            nextRequest: 1,
+            requests: {},
+        };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(storePath, 'utf-8'));
+        return {
+            version: 2,
+            nextRequest: Number.isFinite(raw.nextRequest) ? Number(raw.nextRequest) : 1,
+            requests: raw.requests ?? {},
+        };
+    }
+    catch {
+        return {
+            version: 2,
+            nextRequest: 1,
+            requests: {},
+        };
+    }
+}
+function writeMockStore(store) {
+    const storePath = ensureMockCabinetDir();
+    writeFileSync(storePath, JSON.stringify(store, null, 2));
+}
+function nowIso(value) {
+    return value ?? new Date().toISOString();
+}
+function defaultExpiry(createdAt) {
+    return new Date(new Date(createdAt).getTime() + 15 * 60_000).toISOString();
+}
+function isExpired(record, now) {
+    if (!record.expiresAt || record.status !== 'pending') {
+        return false;
+    }
+    return new Date(record.expiresAt).getTime() <= new Date(now).getTime();
+}
+function requestStatusForSession(status) {
+    return status === 'pending' ? 'waiting_for_user' : 'in_progress';
+}
+function toSessionState(record) {
+    return {
+        sessionId: record.sessionId,
+        status: requestStatusForSession(record.status),
+        currentRequestId: record.status === 'pending' ? record.requestId : null,
+        lastEventSeq: 0,
+        browserSessionId: null,
+    };
+}
+function resolveHintFields(fields) {
+    if (fields.length === 0) {
+        return [];
+    }
+    const [first] = fields;
+    if (typeof first === 'string') {
+        return fields.map((fieldKey) => ({ key: fieldKey }));
+    }
+    return fields.map((field) => ({ ...field }));
+}
+function buildRequestKey(input) {
+    return JSON.stringify({
+        sessionId: input.sessionId,
+        fillRef: input.fillRef,
+        storedSecretRef: input.storedSecretRef ?? null,
+        kind: input.kind ?? null,
+        host: input.host,
+        scopeRef: input.scopeRef ?? null,
+        fields: [...input.fields].map((field) => field.key).sort(),
+        purpose: input.purpose,
+    });
+}
+function requestMatchesKey(record, key) {
+    return (buildRequestKey({
+        sessionId: record.sessionId,
+        fillRef: record.fillRef,
+        storedSecretRef: record.storedSecretRef,
+        kind: record.kind,
+        host: record.host ?? '',
+        scopeRef: record.scopeRef,
+        fields: record.fields,
+        purpose: record.purpose,
+    }) === key);
+}
+function nextRequestId(store) {
+    return `sr_mock_${store.nextRequest++}`;
+}
+function requestTypeForStoredSecret(storedSecretRef) {
+    return storedSecretRef ? 'secret_read' : 'secret_write';
+}
+function normalizeRequest(record, now) {
+    if (!isExpired(record, now)) {
+        return record;
+    }
+    return {
+        ...record,
+        status: 'expired',
+        updatedAt: now,
+        resolvedAt: now,
+    };
+}
+function findReusableRequest(store, input) {
+    const requestKey = buildRequestKey(input);
+    const matching = Object.values(store.requests).filter((request) => request.sessionId === input.sessionId && requestMatchesKey(request, requestKey));
+    const reusableFulfilled = matching.find((request) => request.status === 'fulfilled' && request.claims.length === 0);
+    if (reusableFulfilled) {
+        return reusableFulfilled;
+    }
+    return matching.find((request) => request.status === 'pending') ?? null;
+}
+function resolveHost(input) {
+    if (input.secretHint.host) {
+        return resolveCatalogHost(input.secretHint.host);
+    }
+    if (input.page?.url) {
+        return resolveCatalogHost(input.page.url);
+    }
+    throw new Error('secret_request_host_resolution_failed');
+}
+function resolveScopeRef(input) {
+    return input.secretHint.scopeRef;
+}
+export function setMockSecretRequestStorePathForTests(storePath) {
+    testMockSecretRequestStorePath = storePath ? resolve(storePath) : undefined;
+}
+export function createOrReuseMockSecretRequest(input, options = {}) {
+    const store = readMockStore();
+    const now = nowIso(options.now);
+    const fields = resolveHintFields(input.secretHint.fields);
+    const host = resolveHost(input);
+    const scopeRef = resolveScopeRef(input);
+    const existing = findReusableRequest(store, {
+        sessionId: input.sessionId,
+        fillRef: input.fillRef,
+        storedSecretRef: input.secretHint.storedSecretRef,
+        kind: input.secretHint.kind,
+        host,
+        scopeRef,
+        fields,
+        purpose: input.purpose,
+    });
+    if (existing) {
+        const normalized = normalizeRequest(existing, now);
+        store.requests[normalized.requestId] = normalized;
+        writeMockStore(store);
+        return {
+            requestId: normalized.requestId,
+            snapshot: normalized,
+            reused: true,
+            duplicate: false,
+            session: toSessionState(normalized),
+        };
+    }
+    const requestId = nextRequestId(store);
+    const request = {
+        requestId,
+        sessionId: input.sessionId,
+        fillRef: input.fillRef,
+        requestType: requestTypeForStoredSecret(input.secretHint.storedSecretRef),
+        status: 'pending',
+        ...(input.secretHint.storedSecretRef
+            ? { storedSecretRef: input.secretHint.storedSecretRef }
+            : {}),
+        ...(input.secretHint.kind ? { kind: input.secretHint.kind } : {}),
+        host,
+        ...(input.page?.ref ? { pageRef: input.page.ref } : {}),
+        ...(scopeRef ? { scopeRef } : {}),
+        createdAt: now,
+        updatedAt: now,
+        expiresAt: defaultExpiry(now),
+        purpose: input.purpose,
+        fields,
+        claims: [],
+    };
+    store.requests[requestId] = request;
+    writeMockStore(store);
+    return {
+        requestId,
+        snapshot: request,
+        reused: false,
+        duplicate: false,
+        session: toSessionState(request),
+    };
+}
+export function pollMockSecretRequest(sessionId, requestId, options = {}) {
+    const store = readMockStore();
+    const current = store.requests[requestId];
+    if (!current || current.sessionId !== sessionId) {
+        return {
+            success: false,
+            kind: 'not_found',
+            reason: 'MagicPay mock storage did not find a secret request for the provided session ID and request ID.',
+        };
+    }
+    const normalized = normalizeRequest(current, nowIso(options.now));
+    store.requests[requestId] = normalized;
+    writeMockStore(store);
+    return {
+        success: true,
+        result: {
+            requestId,
+            snapshot: normalized,
+            session: toSessionState(normalized),
+        },
+    };
+}
+function transitionRequestDecision(requestId, status, options = {}) {
+    const store = readMockStore();
+    const current = store.requests[requestId];
+    if (!current) {
+        throw new Error('secret_request_not_found');
+    }
+    const now = nowIso(options.now);
+    const normalized = normalizeRequest(current, now);
+    if (normalized.status === 'expired') {
+        store.requests[requestId] = normalized;
+        writeMockStore(store);
+        throw new Error('secret_request_expired');
+    }
+    if (normalized.status !== 'pending') {
+        throw new Error(`secret_request_not_pending:${normalized.status}`);
+    }
+    const decided = {
+        ...normalized,
+        status,
+        updatedAt: now,
+        resolvedAt: now,
+        ...(status === 'fulfilled' ? { approvedAt: now } : {}),
+    };
+    store.requests[requestId] = decided;
+    writeMockStore(store);
+    return decided;
+}
+export function approveMockSecretRequest(requestId, options = {}) {
+    return transitionRequestDecision(requestId, 'fulfilled', options);
+}
+export function denyMockSecretRequest(requestId, options = {}) {
+    return transitionRequestDecision(requestId, 'denied', options);
+}
+export function claimMockSecretRequest(sessionId, requestId, claimId, options) {
+    const store = readMockStore();
+    const current = store.requests[requestId];
+    if (!current || current.sessionId !== sessionId) {
+        throw new Error('secret_request_not_found');
+    }
+    const now = nowIso(options.now);
+    const normalized = normalizeRequest(current, now);
+    if (normalized.status !== 'fulfilled') {
+        throw new Error(`secret_request_not_fulfilled:${normalized.status}`);
+    }
+    const existingClaim = normalized.claims.find((claim) => claim.claimId === claimId);
+    if (!existingClaim && normalized.claims.length > 0) {
+        throw new Error('secret_request_already_claimed');
+    }
+    const storedSecretRef = normalized.storedSecretRef;
+    if (!storedSecretRef) {
+        throw new Error('mock_secret_values_missing');
+    }
+    const values = options.resolveValues(storedSecretRef);
+    if (!values) {
+        throw new Error('mock_secret_values_missing');
+    }
+    const issuedAt = existingClaim?.issuedAt ?? now;
+    if (!existingClaim) {
+        store.requests[requestId] = {
+            ...normalized,
+            updatedAt: now,
+            claims: [...normalized.claims, { claimId, issuedAt }],
+        };
+        writeMockStore(store);
+    }
+    return {
+        requestId,
+        issuedAt,
+        expiresAt: normalized.expiresAt,
+        secret: {
+            values: values,
+            source: 'saved_secret',
+            storedSecretRef,
+            ...(normalized.kind ? { kind: normalized.kind } : {}),
+        },
+    };
+}
+export function resetMockSecretRequestStore() {
+    const storePath = resolveConfiguredStorePath();
+    if (existsSync(storePath)) {
+        rmSync(storePath, { force: true });
+    }
+}
+export const __testMockSecretCabinet = {
+    defaultExpiry,
+    readMockStore,
+};

package/dist/mock-secret-store.d.ts

@@ -0,0 +1,12 @@
+import type { SecretCatalog, StoredSecretMetadata } from '@mercuryo-ai/magicpay-sdk';
+export declare function setMockSecretStorePathForTests(storePath?: string): void;
+export declare function normalizeMerchantKey(value: string): string;
+export declare function listMockStoredSecretsForHost(hostOrUrl: string, options?: {
+    merchantKey?: string;
+}): StoredSecretMetadata[];
+export declare function fetchMockSecretCatalog(hostOrUrl: string, options?: {
+    merchantKey?: string;
+    syncedAt?: string;
+}): SecretCatalog;
+export declare function resolveMockStoredSecretValues(storedSecretRef: string): Record<string, string> | null;
+//# sourceMappingURL=mock-secret-store.d.ts.map

package/dist/mock-secret-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-secret-store.d.ts","sourceRoot":"","sources":["../src/mock-secret-store.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAiGrF,wBAAgB,8BAA8B,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAEvE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GACL,oBAAoB,EAAE,CAgBxB;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,GACL,aAAa,CAUf;AAED,wBAAgB,6BAA6B,CAC3C,eAAe,EAAE,MAAM,GACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAS/B"}

package/dist/mock-secret-store.js

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getMagicPayMockStoredSecretsPath } from '@mercuryo-ai/magicpay-home';
+import { resolveCatalogHost } from '@mercuryo-ai/magicpay-sdk/core';
+const MOCK_SECRET_STORE_PATH_ENV = 'MAGICPAY_MOCK_SECRET_STORE_PATH';
+const DEFAULT_MOCK_SECRET_STORE_PATH = fileURLToPath(new URL('./mock-stored-secrets.json', import.meta.url));
+const USER_MOCK_SECRET_STORE_PATH = getMagicPayMockStoredSecretsPath();
+let testMockSecretStorePath;
+function normalizeLookupValue(value) {
+    return value.trim().toLowerCase();
+}
+function storedSecretAppliesToHost(metadata, host) {
+    const normalizedHost = normalizeLookupValue(host);
+    const applicabilityValue = metadata.applicability.value
+        ? normalizeLookupValue(metadata.applicability.value)
+        : undefined;
+    switch (metadata.applicability.target) {
+        case 'global':
+            return true;
+        case 'host':
+            return applicabilityValue === normalizedHost;
+        case 'site':
+            return (applicabilityValue === normalizedHost ||
+                (typeof applicabilityValue === 'string' &&
+                    normalizedHost.endsWith(`.${applicabilityValue}`)));
+        default:
+            return false;
+    }
+}
+function resolveConfiguredStorePath() {
+    if (testMockSecretStorePath) {
+        return testMockSecretStorePath;
+    }
+    const configured = process.env[MOCK_SECRET_STORE_PATH_ENV]?.trim();
+    if (configured) {
+        return resolve(configured);
+    }
+    if (existsSync(USER_MOCK_SECRET_STORE_PATH)) {
+        return USER_MOCK_SECRET_STORE_PATH;
+    }
+    if (existsSync(DEFAULT_MOCK_SECRET_STORE_PATH)) {
+        return DEFAULT_MOCK_SECRET_STORE_PATH;
+    }
+    return null;
+}
+function resolveMockSecretStorePath() {
+    const storePath = resolveConfiguredStorePath();
+    if (storePath) {
+        return storePath;
+    }
+    throw new Error(`mock_secret_store_not_found:${DEFAULT_MOCK_SECRET_STORE_PATH}:${USER_MOCK_SECRET_STORE_PATH}`);
+}
+function cloneMetadata(metadata) {
+    return {
+        ...metadata,
+        fieldKeys: [...metadata.fieldKeys],
+        fieldPolicies: metadata.fieldPolicies ? { ...metadata.fieldPolicies } : undefined,
+        preferredForMerchantKeys: metadata.preferredForMerchantKeys
+            ? [...metadata.preferredForMerchantKeys]
+            : undefined,
+    };
+}
+function loadMockStoredSecretRecords() {
+    return JSON.parse(readFileSync(resolveMockSecretStorePath(), 'utf-8'));
+}
+function preferenceScore(metadata, merchantKey) {
+    return metadata.preferredForMerchantKeys?.some((candidate) => normalizeLookupValue(candidate) === merchantKey)
+        ? 1
+        : 0;
+}
+export function setMockSecretStorePathForTests(storePath) {
+    testMockSecretStorePath = storePath ? resolve(storePath) : undefined;
+}
+export function normalizeMerchantKey(value) {
+    return normalizeLookupValue(value);
+}
+export function listMockStoredSecretsForHost(hostOrUrl, options = {}) {
+    const host = resolveCatalogHost(hostOrUrl);
+    const merchantKey = normalizeMerchantKey(options.merchantKey ?? host);
+    return loadMockStoredSecretRecords()
+        .filter((record) => storedSecretAppliesToHost(record.metadata, host))
+        .sort((left, right) => {
+        const preferenceDelta = preferenceScore(right.metadata, merchantKey) - preferenceScore(left.metadata, merchantKey);
+        if (preferenceDelta !== 0) {
+            return preferenceDelta;
+        }
+        return left.metadata.displayName.localeCompare(right.metadata.displayName);
+    })
+        .map((record) => cloneMetadata(record.metadata));
+}
+export function fetchMockSecretCatalog(hostOrUrl, options = {}) {
+    const host = resolveCatalogHost(hostOrUrl);
+    return {
+        host,
+        syncedAt: options.syncedAt ?? new Date().toISOString(),
+        storedSecrets: listMockStoredSecretsForHost(host, {
+            merchantKey: options.merchantKey ?? host,
+        }),
+    };
+}
+export function resolveMockStoredSecretValues(storedSecretRef) {
+    const match = loadMockStoredSecretRecords().find((record) => record.metadata.storedSecretRef === storedSecretRef);
+    if (!match) {
+        return null;
+    }
+    return { ...match.values };
+}

package/dist/mock-stored-secrets.json

@@ -0,0 +1,180 @@
+[
+  {
+    "metadata": {
+      "storedSecretRef": "secret_site_login_airline_primary",
+      "kind": "login",
+      "scope": "site",
+      "displayName": "Airline account login",
+      "fieldKeys": ["username", "password"],
+      "fieldPolicies": {
+        "username": "deterministic_only",
+        "password": "deterministic_only"
+      },
+      "intentRequired": true,
+      "applicability": {
+        "target": "site",
+        "value": "airline.example"
+      }
+    },
+    "values": {
+      "username": "traveler@example.com",
+      "password": "test-airline-password"
+    }
+  },
+  {
+    "metadata": {
+      "storedSecretRef": "secret_host_login_streaming_primary",
+      "kind": "login",
+      "scope": "site",
+      "displayName": "Streaming auth login",
+      "fieldKeys": ["username", "password"],
+      "fieldPolicies": {
+        "username": "deterministic_only",
+        "password": "deterministic_only"
+      },
+      "intentRequired": true,
+      "applicability": {
+        "target": "host",
+        "value": "auth.streaming.example"
+      }
+    },
+    "values": {
+      "username": "streaming@example.com",
+      "password": "test-streaming-password"
+    }
+  },
+  {
+    "metadata": {
+      "storedSecretRef": "secret_global_identity_primary",
+      "kind": "identity",
+      "scope": "global",
+      "displayName": "Primary passport identity",
+      "fieldKeys": [
+        "full_name",
+        "document_number",
+        "date_of_birth",
+        "nationality",
+        "issue_date",
+        "expiry_date",
+        "issuing_country"
+      ],
+      "fieldPolicies": {
+        "full_name": "llm_assisted",
+        "document_number": "deterministic_only",
+        "date_of_birth": "deterministic_only",
+        "nationality": "llm_assisted",
+        "issue_date": "deterministic_only",
+        "expiry_date": "deterministic_only",
+        "issuing_country": "llm_assisted"
+      },
+      "intentRequired": true,
+      "applicability": {
+        "target": "global"
+      }
+    },
+    "values": {
+      "full_name": "Dmitry Ukhanov",
+      "document_number": "AA1234567",
+      "date_of_birth": "1990-05-18",
+      "nationality": "RU",
+      "issue_date": "2020-01-10",
+      "expiry_date": "2030-01-10",
+      "issuing_country": "RU"
+    }
+  },
+  {
+    "metadata": {
+      "storedSecretRef": "secret_site_identity_aviasales_primary",
+      "kind": "identity",
+      "scope": "site",
+      "displayName": "Aviasales passenger identity",
+      "fieldKeys": [
+        "full_name",
+        "document_number",
+        "date_of_birth",
+        "nationality",
+        "issue_date",
+        "expiry_date",
+        "issuing_country"
+      ],
+      "fieldPolicies": {
+        "full_name": "llm_assisted",
+        "document_number": "deterministic_only",
+        "date_of_birth": "deterministic_only",
+        "nationality": "llm_assisted",
+        "issue_date": "deterministic_only",
+        "expiry_date": "deterministic_only",
+        "issuing_country": "llm_assisted"
+      },
+      "intentRequired": true,
+      "applicability": {
+        "target": "site",
+        "value": "aviasales.ru"
+      }
+    },
+    "values": {
+      "full_name": "Dmitry Ukhanov",
+      "document_number": "751234567",
+      "date_of_birth": "1990-05-18",
+      "nationality": "RU",
+      "issue_date": "2020-01-10",
+      "expiry_date": "2030-01-10",
+      "issuing_country": "RU"
+    }
+  },
+  {
+    "metadata": {
+      "storedSecretRef": "secret_global_card_default",
+      "kind": "payment_card",
+      "scope": "global",
+      "displayName": "Primary payment card",
+      "fieldKeys": ["cardholder", "pan", "exp_month", "exp_year", "cvv"],
+      "fieldPolicies": {
+        "cardholder": "deterministic_only",
+        "pan": "deterministic_only",
+        "exp_month": "deterministic_only",
+        "exp_year": "deterministic_only",
+        "cvv": "deterministic_only"
+      },
+      "intentRequired": true,
+      "applicability": {
+        "target": "global"
+      }
+    },
+    "values": {
+      "cardholder": "Dmitry Ukhanov",
+      "pan": "4242424242424242",
+      "exp_month": "12",
+      "exp_year": "2030",
+      "cvv": "123"
+    }
+  },
+  {
+    "metadata": {
+      "storedSecretRef": "secret_global_card_travel",
+      "kind": "payment_card",
+      "scope": "global",
+      "displayName": "Travel payment card",
+      "fieldKeys": ["cardholder", "pan", "exp_month", "exp_year", "cvv"],
+      "fieldPolicies": {
+        "cardholder": "deterministic_only",
+        "pan": "deterministic_only",
+        "exp_month": "deterministic_only",
+        "exp_year": "deterministic_only",
+        "cvv": "deterministic_only"
+      },
+      "intentRequired": true,
+      "applicability": {
+        "target": "global"
+      },
+      "preferredForMerchantKeys": ["airline.example", "booking.example"]
+    },
+    "values": {
+      "cardholder": "Dmitry Ukhanov",
+      "pan": "4000002760003184",
+      "exp_month": "11",
+      "exp_year": "2029",
+      "cvv": "456"
+    }
+  }
+]

package/dist/otel-exporter.d.ts

@@ -0,0 +1,58 @@
+import { type OtlpTraceRequest } from './otel-projector.js';
+export type OtlpHttpJsonExporterConfig = {
+    tracesEndpoint: string;
+    headers: Record<string, string>;
+    timeoutMs: number;
+    protocol: 'http/json';
+};
+export type ExportStepTraceResult = {
+    attempted: false;
+    reason: 'config_missing' | 'run_missing' | 'step_missing' | 'unsupported_protocol';
+} | {
+    attempted: true;
+    success: true;
+    status: number;
+    payload: OtlpTraceRequest;
+} | {
+    attempted: true;
+    success: false;
+    status?: number;
+    reason: string;
+    payload: OtlpTraceRequest;
+};
+export type ExportRunRootTraceResult = {
+    attempted: false;
+    reason: 'config_missing' | 'run_missing';
+} | {
+    attempted: true;
+    success: true;
+    status: number;
+    payload: OtlpTraceRequest;
+} | {
+    attempted: true;
+    success: false;
+    status?: number;
+    reason: string;
+    payload: OtlpTraceRequest;
+};
+export declare function loadOtlpHttpJsonExporterConfig(env?: NodeJS.ProcessEnv): OtlpHttpJsonExporterConfig | null;
+export declare function buildRunStepOtlpTraceRequest(runId: string, stepId: string): OtlpTraceRequest | null;
+export declare function exportRunStepToOtlpHttpJson(params?: {
+    runId: string;
+    stepId: string;
+    config?: OtlpHttpJsonExporterConfig | null;
+    fetchImpl?: typeof fetch;
+}): Promise<ExportStepTraceResult>;
+export declare function buildRunRootOtlpTraceRequest(runId: string): OtlpTraceRequest | null;
+export declare function exportRunRootToOtlpHttpJson(params?: {
+    runId: string;
+    config?: OtlpHttpJsonExporterConfig | null;
+    fetchImpl?: typeof fetch;
+}): Promise<ExportRunRootTraceResult>;
+export declare function exportRunStepToOtlpHttpJsonBestEffort(runId: string | undefined, stepId: string | undefined, options?: {
+    fetchImpl?: typeof fetch;
+}): Promise<ExportStepTraceResult>;
+export declare function exportRunRootToOtlpHttpJsonBestEffort(runId: string | undefined, options?: {
+    fetchImpl?: typeof fetch;
+}): Promise<ExportRunRootTraceResult>;
+//# sourceMappingURL=otel-exporter.d.ts.map

package/dist/otel-exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-exporter.d.ts","sourceRoot":"","sources":["../src/otel-exporter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAM7H,MAAM,MAAM,0BAA0B,GAAG;IACvC,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,WAAW,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAC7B;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,gBAAgB,GAAG,aAAa,GAAG,cAAc,GAAG,sBAAsB,CAAC;CACpF,GACD;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;CAC3B,GACD;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,KAAK,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;CAC3B,CAAC;AAEN,MAAM,MAAM,wBAAwB,GAChC;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,gBAAgB,GAAG,aAAa,CAAC;CAC1C,GACD;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;CAC3B,GACD;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,KAAK,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;CAC3B,CAAC;AAsEN,wBAAgB,8BAA8B,CAC5C,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,0BAA0B,GAAG,IAAI,CA0CnC;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAenG;AAED,wBAAsB,2BAA2B,CAC/C,MAAM,GAAE;IACN,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,0BAA0B,GAAG,IAAI,CAAC;IAC3C,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAI1B,GACA,OAAO,CAAC,qBAAqB,CAAC,CAuDhC;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAOnF;AAED,wBAAsB,2BAA2B,CAC/C,MAAM,GAAE;IACN,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,0BAA0B,GAAG,IAAI,CAAC;IAC3C,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAG1B,GACA,OAAO,CAAC,wBAAwB,CAAC,CAkDnC;AAED,wBAAsB,qCAAqC,CACzD,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CACrB,GACL,OAAO,CAAC,qBAAqB,CAAC,CAUhC;AAED,wBAAsB,qCAAqC,CACzD,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CACrB,GACL,OAAO,CAAC,wBAAwB,CAAC,CASnC"}